Find Back-End Developer Jobs

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

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.

Ruby on Rails, Java, Elixir, React.js, GraphQL, Node.js, AWS, Redis, Spark & Scala, (Data team)

At Noyo our primary tech stack is Python/Flask for our backend services (typically on top of PostgreSQL); our frontend web applications are built using React. We are a cloud-native company, we deploy everything on Google Cloud Platform via a combination of Kubernetes and serverless applications.

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

Frontend: React (Typescript). Backend: NestJS (Typescript), TypeORM, Postgres. Hosting: AWS (ECS, RDS, S3 + Cloudfront, Codebuild).

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

Rails API, Ruby, Python, Postgres, PostGIS, React.js, Redux, Typescript, Heroku, AWS, Terraform

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

Frontend: React, Relay, Flow, Jest, Enzyme.

Mobile: React Native, Apollo.

Backend: Ruby on Rails, Postgres, GraphQL, Python, RSpec, Java, Kotlin, MongoDB, Clojure.

CI: GitHub, Buildkite.

Infrastructure: AWS, Ruby, Terraform, Kubernetes.

APIs & Services: python+flask, thrift for API specification.

Backend infrastructure: AWS tools (S3, SQS, SNS, etc.). Graylog for logging. Cloudwatch, Icinga, PagerDuty for monitoring. Jenkins for CI/CD. Airbrake for exception monitoring.

Releasing: Regular releases from master twice weekly + Out-of-cycle releases when needed to facilitate the roll-out of specific features.

Mobile: Kotlin is our primary language for our native Android apps. Swift3 is our primary language for our native iOS apps.

Front-end Web: React, hooks, redux, typescript & modern javascript.

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.

PHP, Javascript, React, VueJS, Node.js, Next.js, Fastify, Java, Python, Perl, Kotlin, Swift, Objective-C, C#, Lua, MySQL, Redshift, DynamoDB, memcached, Redis, Kinesis, Kafka, Docker, Lambda, Linux, Nginx, Puppet, Terraform, Elasticsearch, Vespa, Haproxy, Splunk, Circonus, Redshift, Cloudfront, DynamoDB, S3, AWS

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.

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

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.

Frontend – Custom MV* JS Framework, React, SASS, Handlebars

Backend – Perl, Go, NodeJS, Python

Data Science – Jupyter, Python, Clickhouse

Internal Operations – Linux, Terraform, Chef, Azure, Jenkins

Privacy Engineering – JavaScript, Python

iOS + macOS – Swift, Bitrise

Android – Kotlin, Jenkins

Windows - C#

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

Backend: Python3, Deployed on AWS Lambda + ApiGateway, GraphQL endpoint.

Frontend: React written in Typescript.

Clojure backend, React front end, MongoDB, Kubernetes, AWS. Full stack here.

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

React, React Native, Node.js, Elasticsearch, Redis, AWS, Kubernetes, Kafka

TypeScript / Javascript / Node.js, ActionHero, React + Next.js, Postgres & Redis, and whole lot of third-party APIs!

Clojure, React, Postgres, AWS, Git

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.

We use whatever tools are appropriate to accomplish the task at hand.

The backend stack currently consists of Node.js, Apollo server (GraphQL), PostgreSQL, Docker and Lambda in AWS. We also have a strong bias toward a micro-service architecture.

The frontend stack currently consists of React Native, TypeScript, Expo, Apollo client (GraphQL), and Jest testing framework. We have a mobile app with cross-platform support.

JavaScript, Python, Node.js, React + React Native, AWS Lambda, Spark, Kinesis, MongoDB, Redshift

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

React, Node.js, Python, Java

Ruby on Rails, React, Next.Js, Typescript, GraphQL, GitHub, Linear, Heroku, Figma

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.

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