Find Back-End Developer Jobs

Core: Python Frontend: react, typescript, 3js Backend: PostgresQL, AWS 3D graphics: openGL, C++

React, GraphQL, Go, Kubernetes, Docker, PostgreSQL, TypeScript

Frontend: Clojurescript, React, GraphQL

Backend: Clojure, JVM

Infrastructure: Kafka, Docker, Kubernetes, Packer, Terraform, AWS

Data: BigQuery, Tableau, Apache Beam

Python, React, PHP, Go, CloudFlare, Typescript, CSS, GraphQL, Google Cloud Platform

AngularJS, Backbone.js, Django, Ember.js, Flask, Node.js, Ruby on Rails, C++, Golang, Java, JavaScript, Kotlin, Python, Swift, React, Objective-C

Backend: Ruby on Rails. Frontend: ReactJS + Typescript.

Go for backend services, Node and Typescript for our web services, Next.js and React/Typescript on the frontend. We run on AWS with Kubernetes for containerization, and gRPC and protobufs for internal service communication.

Airtable’s core stack is written using JavaScript, augmented with static type checking and other tools. We use Node.js on the backend, and mostly React on the frontend, but our application requirements drive a substantial amount of custom software architecture; that is, Airtable is pretty far from a boilerplate “React + Express” application. Mobile apps are currently native and use JavaScript in webviews where appropriate. Our data infrastructure, which drives our data science and business intelligence efforts, is primarily in Python. We periodically evaluate adding other languages into our codebase for ecosystem or performance reasons; philosophically, we try hard to standardize on a few languages and toolchains so that investments in tooling can be leveraged across larger fractions of our engineering effort. Our production infrastructure runs on a variety of AWS services, principally using Terraform for deployment; for logging, aggregation, monitoring, and alerting, we use a mixture of ELK and some carefully selected third-party services.

Infrastructure: AWS, Cloudwatch, Kubernetes, Ingress, Helm, Route53, Nginx, Jenkins, Sentry, RDS / PostgreSQL, Redis, Istio.

Backend: Python 3, Flask, Redis, RDS / PostgreSQL, Peewee, Nginx, Kubernetes, Docker.

Frontend: TypeScript, Vue.js, Capacitor, SASS, Vuetify.

NextJS, React, Typescript, GraphQL, Kafka, Python, Django

Frontend: React Native (TypeScript), React (TypeScript). Backend: Django + Celery (Python), Redis, Heroku, AWS S3, AWS Aurora (PostgreSQL).

We use Python and PostgreSQL on our backend. On our frontend plugins, we use Javascript and React.

Programming: Python, Flask, pipenv, JSON Data: PostgreSQL, Vault, ActiveMQ Infrastructure: Docker, Terraform, Ansible, AWS, Linux, immutable

On the backend, our stack runs on Python3 in combination with GraphQL, on top of AWS infrastructure like Lambda & ApiGateway, to deliver the best experience and value to our customers.

On the frontend, we currently have three clients: web, iOS, and Android. Our existing web stack is an AngularJS (also known as Angular 1) app, within which we have (more recently, i.e. past year) been writing React components. The new stack is entirely React, written in Typescript, and includes modern libraries for things like state management, api requests, analytics, and error handling. It’s also built in such a way that we can package it as a native iOS/Android app, getting us closer to our goal of writing ~once while deploying on all 3 platforms. The iOS stack is Objective C and Swift and the Android’s stack is Java and Kotlin.

Clojure, React, Postgres, AWS, Git

Python, Django, React JS, AWS

Node.js & Express backend, Golang CLI, Postgres database, Google Cloud

Frontend: Typescript, React… Backend: Python…

Qualified is a modern web app with a React UI interfacing over GraphQL, REST, and WebSockets with a Ruby on Rails backend. The data and messaging layers are built on PostgreSQL, Redis, and ClickHouse.

Backend: Ruby on Rails, MySQL, Elasticsearch, Lambdas Frontend: React Infrastructure: AWS, Docker, Terraform CI: GitHub, Jenkins

AWS, Angular 10, Go 1.14, Java 8+, Postgres 11.5, Rails 6, Ruby 2.7+, Terraform, TypeScript 3.5

Backend: Node + Express, Typescript, Go Microservices. Frontend: Next.js, React + Hooks, Storybook. Infrastructure: Heroku + AWS, CircleCI, DataDog.

Node.js, Next.js/React, PostgreSQL, MongoDB, AWS. See our detailed stack here.

AWS PHP NodeJS Agile React Javascript ES6, Node.js, AWS (Lambda, SNS, EC2, ECS). SQL NoSQL databases (MySQL, MongoDB). GIT/Bitbucket

Node.js, TypeScript, Postgres, AWS, Terraform, Ansible, React, GraphQL

Full-stack: TypeScript

Backend:

• NestJS
• GraphQL
• Graphile Worker
• Postgres

Frontend:

• React
• Next.js
• Tailwind

Other:

• Vercel
• Semaphore CI

Blog post on our tech stack

Lever uses our own open source real-time framework called Derby that syncs all data via Operational Transformation. OT is the way we handle concurrency conflicts for any piece of data that is edited at the same time. In addition to real-time sync, OT allows us to provide a smoother UI since we can render updates on the client instantly without waiting for our backend to respond, while still guaranteeing consistency.

Lever makes extensive use of AWS, Docker, Node, Mongo, ElasticSearch, and Redis within our infrastructure. We use tools like Hubot to streamline deployments and Datadog to see what’s going on under the hood. In addition to automating all the things, we love to version them too! Our systems are all created using Terraform and Chef, working together to ensure consistency at all costs.

Frontend: React (Typescript)

Backend: NestJS (Typescript), TypeORM, Postgres

Hosting: AWS (ECS, RDS, S3 + Cloudfront)

Dev-ops: CircleCI, Terraform

We have a service oriented stack deployed on AWS using containers. Most of our backend services are written in Go, with the exception of an NLP/ML service written in Python. Services talk to each other using gRPC.

Our web application is served statically from Cloudfront/S3 and is written using React. It is a Progressive Web App, with a service worker to speed up delivery.

We integrate with third party software such as Google Drive, Calendar, Jira, GitHub, Asana, Slack. These areas are some of the most complex parts of our systems. They’re also some of the most important: integrations enable the “magic” of a user coming to Range in the morning and seeing all of their work from the previous day already gathered in one place.

AWS, DynamoDB, Go, InfluxDB, Kubernetes (EKS), PostgreSQL, Python, ReactJS 16+ (Hooks), Swift, Terraform

Golang, React, Redux, MongoDB, ElasticSearch, Redis, Kinesis, NATS, TimescaleDB, Lambda, Node.js, Postgres, Typescript

Python for our backend code, and the code that runs on the reactors. ES6 and Typescript on the frontend. We use React embedded into a flask site. We have a few different APIs, but we primarily use GraphQL.

Our web services are written with Ruby (Rails) on the backend and Typescript (React) on the frontend. We use GraphQL for most client-server communication, along with a few protobuf APIs for server-server communication. Our services are powered with Kubernetes and hosted on AWS.

Web: PHP, JavaScript, TypeScript, React/Redux, MySQL, Docker, and Elixir.

Mobile: Kotlin, Swift, Java, Objective-C, React Native, and Electron.

Systems: Docker, Nginx, PHP, C, Lua, MySQL, MongoDB, Node.js, Statsd, Graphite, Prometheus, Elasticsearch, Logstash, Hadoop, MogileFS, HDFS, and BGP.

Data: Hive, Impala, HBase, Spark, HDFS, Python, Java, Scala, Kafka, Elasticsearch, MySQL, Solr, and Lucene.

Python, Flask, Javascript, React, HTML/CSS, Sass, React Native, Expo, GraphQL, Postgres, Redis, Heroku, AWS

Product: React, Next.js, and TypeScript. Infrastructure: Go, Cadence, Presto, Flink, Kubernetes, and Terraform.

We’re on service-oriented architecture. Our backend is composed of a collection of Java services that communicate via RPC. Our frontend web stack is a React/Redux application. We use Objective-C and Swift in the iOS app and Kotlin in the Android app. Our data infrastructure is cloud native in AWS and includes S3, EMR, Redshift/RDS, Lambda, and ECS.

Python, Airflow, Docker (Marathon/Mesos), Snowflake (currently migrating from Redshift), Databricks (Spark on EC2), GitHub, Kafka, Segment.io, Fivetran, AWS (S3, Kinesis Firehose)

Backend: Node.js, Express, MongoDB/Mongoose, Testing (Jest, Supertest, Nock), Cloudflare. Frontend: Angular 1, React. Hosting/Infrastructure: Heroku, MongoDB Atlas, GitHub, Codeclimate, CircleCI.

Dark’s backend is written in a combination of OCaml, Rust, and Dark (that’s right, Dark is partially built in Dark!). We use Kubernetes and Postgres, running on top of Google Cloud.

Our frontend is also in OCaml – we don’t expect you to know OCaml before you join, and you typically learn it in the first few weeks. We compile the OCaml to JS using Bucklescript/ReasonML, and use a framework similar to Redux or Elm for managing state.

Our clients (Android, iOS, and web) and backend are all built in JavaScript using technologies like React, React Native, Nodejs, and GraphQL.