Find React Developer Jobs

Elixir/Phoenix, Ruby/Rails, Javascript, React, PostgreSQL, Elastic, Kafka, Heroku, and Google Cloud Platform

React, MySQL, Java, MongoDB, Redis, Amazon S3, Go, Amazon RDS, Swift, Objective-C, Kafka, Scala, Cassandra, Amazon DynamoDB, Kotlin, Apache Spark, Amazon Redshift, gRPC, Amazon Redshift Spectrum, Elasticsearch, Mixpanel, TensorFlow, GitHub, Jenkins, Webpack, Kubernetes, Datadog, Terraform, Chef, Crashlytics, Bazel, Envoy

Web - Node, React, Python, PostgreSQL.

Mobile - React Native, Swift (iOS) / Java (Android).

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

d3.js/React/Redux single page webapp, Go backend, multi-language support for client libraries

Our main web service is in Node.js, and most other services are in Python (mostly machine learning services, using Keras, Tensorflow, etc). Our frontend is React + Redux, database is PostgreSQL, and services run in a Kubernetes cluster hosted on Google Cloud Platform (Google Kubernetes Engine).

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

Mobile: React Native, Apollo.

Backend: Ruby on Rails, Postgres, GraphQL, Python, RSpec.

CI: GitHub, Buildkite.

Infrastructure: AWS, Python.

On the frontend, we use TypeScript, React, Redux, GraphQL, Apollo. On the backend, we use Node.js, Go, TypeScript, MySQL, Elasticsearch, Redis. Everything is containerized in Docker and running on Kubernetes.

On the web, we’re a Ruby on Rails shop with a React.js front-end. Other items in our stack are Sass, Webpacker, Postgres, Mongo, Kafka, S3, AWS Lambda, Terraform, and Docker.

On Mobile, our apps are primarily built with React Native alongside some custom native libraries in Java, Objective-C, Swift, and C++ for core functionalities. We use Apollo and GraphQL, alongside Redux for local state management.

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.

Full stack Javascript, Typescript, Node, React, Redux, Apollo, GraphQL, Redis, MongoDB, Elasticsearch, AWS (Codepipeline, ECR, ECS, Fargate) and serverless (Lambda, SQS, SNS).

Rails 5.2, Ruby 2.3.7, Python, R, PostgreSQL 9.6, React 0.17, AWS, Docker, RabbitMQ, Sidekiq, Snowflake

We use whatever tools are appropriate to accomplish the task at hand. The backend stack currently consists of Node.js, Express, GraphQL, PostgreSQL, Docker and Lambda in AWS. We also have a strong bias towards 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.

We use Golang for our backend, Typescript and React for our web client, GraphQL to fetch data from our backend, and React Native for our mobile app. Direct experience with these technologies is not required.

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

AWS rds + mysql for data storage API is in python + flask apache thrift for interface definition android app is in java ios apps in swift 3 front-end web is in python, flask, node, and react

Our core application tech is built in Python/Django/DRF, Backbone.js/Marionette, React/Redux, Node.js/ShareDB, WebRTC and websockets. We deploy to AWS with EKS, Docker, Terraform, and Chef.

Ruby on Rails, React, Redux, React Native, Backbone, Apollo, GraphQL, Redis, ElasticSearch, Postgres, Heroku, Airflow, Python 3

We use React and React Native for our frontends and Node.js for our backend, which is built around the microservices paradigm. Some services have been migrated to serverless logic, in order to have more concurrent users on Aula simultaneously.

In order to support this architecture, we use Docker and everything is deployed and managed on our AWS infrastructure which is defined by Terraform code. More details here!

Web stack: Django, GraphQL, React, Postgres. Data pipeline: Spark, Kafka, Elastic Search, Scala. Infra: AWS.

React, React Native, Node.js, Elasticsearch, Redis, Heroku, AWS

React/Redux, Android (native, Kotlin), Python (using Flask / SQLAlchemy), Postgresql, AWS

Backend: Ruby on Rails, Postgres, Elasticsearch, Google Cloud Platform, Kubernetes.

Frontend: Typescript, React, Redux.

Data: BigQuery, BigTable, DataFlow, DataProc.

For Comply: JS, React, Ruby, Flow, Postgres. For Deploy: Cloud IaaS (AWS), Docker, PostgreSQL, Redis, sqlite.

Javascript (React/Redux), Ruby on Rails, Scala, Postgres, LittleTable

AWS (ECS, ECR, EC2, S3, Cloudwatch…), Docker, Ruby (Sinatra), Python, Postgresql, Mysql, Swift, Kotlin, Sentry, Jenkins, React.js

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

Python, Flask, PostgreSQL, Redis, Heroku, AWS, GraphQL, React Native

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. We also periodically evaluate adding other languages into our codebase for ecosystem or performance reasons. Mobile apps are currently written in the standard platform language, mixed with JavaScript in webviews where appropriate. Our production infrastructure runs on a variety of AWS services, principally using Terraform for deployment; for data collection, aggregation, monitoring, and alerting, we use a mixture of ELK and some carefully selected third-party services.

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

Frontend: express, react, redux, bootstrap

Middleware: express

Backend: everything but dominantly GoLang running on AWS

Backend: Node.js, Express, MongoDB/Mongoose, Testing (Mocha, Jest, Supertest, Nock), and Nginx (Caching server, SSL certificate generation service).

Frontend: Angular 1, React.

Hosting/Infrastructure: Heroku, AWS, MongoDB Atlas, GitHub, Codeclimate, CircleCI.

Our engineering team builds software using JavaScript/ES6, React, Redux, Swift, and Objective-C on the frontend and Python, bash, and Bitcoin Core on the backend.

Backend: Ruby on Rails, Frontend: ReactJS

Web: Typescript, React Native Web

Backend: Typescript, Express, TypeORM, PostgreSQL hosted on Heroku

Agent: Typescript, React, Material UI

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

Ruby, Rails, Javascript, React, MySQL, Kubernetes

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

Python, MySQL, Redis, Kinesis, HAProxy, Linux, Javascript, React, Redux, Flux, Flow, Elasticsearch, AWS, Jenkins, MyPy, nginx

Node.js, React.js, Redis / Mongo, AWS, Kubernetes / Terraform / Docker

Node.js, TypeScript, React, GraphQL, Docker, Terraform, Go, AWS

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. Is 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.

Back: Node, Golang

SRE: Terraform, Kubernetes, Rancher, AWS, MongoDB, Postgres, RabbitMq, ElasticSearch, Docker

Front: React-like frameworks, Webpack, Javascript, AngularJS (only until we kill the old product)

Some of the technologies we use to build Thread include: Python, Django, ReactJS, PostgreSQL, Redis, Debian, Docker, Memcache, nginx, Ansible, Jenkins, Gunicorn, Luigi, Pandas, scikit-learn, git.

Some popular languages and frameworks we use are: (Web) JavaScript, Python, Go, Java, PHP, Ruby | Node.js, Express, Spring, ReactJS, Redux, Typescript, Rails. (Android) Kotlin, Java | RxJava, React Native. (iOS) Swift, Objective-C | RxSwift, React Native

Frontend is React Native for mobile, and we’re experimenting with React Native Web on the web side.

Backend is currently Java deployed using Kubernetes, but we have a polyglot approach to problem solving, and we will likely end up with a backend that reflects that.

GCP, K8s, Docker, Clojure, Elastic Search, SQL, Node, Swift, React Native, React, Redux

Ruby 2.3, Rails 4.2+, Rspec React, Jest ES6+, Babel NodeJS 8.1 GraphQL PostgreSQL, MySQL Redis AWS Periscope

Ruby on Rails, React, JavaScript (ES6), HTML+CSS, Figma, Webflow, Pencil and Paper

The YC internal software is mostly written in Ruby on Rails and React. We’re hosted on AWS and PostgreSQL. Some experience developing web apps would be helpful, but we don't care if you've used Rails before.

Note: Hacker News is written in Lisp, but Hacker News is run by a separate team. While we don't use Lisp anymore in our internal software, we retain the original motivation for it, and welcome Lisp hackers to join us.

Python (Flask)

ReactJS / Redux

MongoDB

React

Ruby on Rails

Java

AWS

Ruby / Javascript / Python / Golang

Sinatra / Rails / React

MySQL / Mongo

Presto for data warehouse

Docker / Kubernetes for deployment

REST / JSON / gRPC for service communication

Frontend: Javascript, React, Typescript, Flow, Mobx, Stylus, Redux, Reactive JS, Styled Components, Focal (our own in-house, open-sourced state management framework)

Mobile (iOS and Android): Java, OkHttp, Butterknife, Retrofit, XCode, Swift, ReactiveCocoa, ReactiveSwift, Kickstarter-Prelude, Argo, Runes, Curry

Desktop app: CoffeeScript, Electron.js, C#, F#, ReactiveUI

Internal tools: Angular, Elm, ClojureScript

Backend: Java, Scala, Python, Haskell, Lisp, Clojure, Go, C++

NLP/Research teams: sklearn, TensorFlow, PyTorch, CNN, RNN, Keras, Seq2Seq, xgboost, CRFs, nltk/spacy/OpenNLP, OpenNMT, Jupyter notebooks

Ruby on Rails, React, React Native (iOS & Android), Postgres, Sidekiq … and lots of testing and CI tools!

TypeScript, JavaScript, and React

Scala (high performance backend)

Python (infrastructure management and data analysis)

Android and iOS

Luna1 (legacy in-house functional reactive framework, similar to Meteor)

Frontend: React/Redux. Legacy JSP (although increasingly less!)

Monolith backend: Java on Tomcat.

Microservices backend: Java on Spring.

API: Java w/ Swagger.

TechOps: Hashicorp stack + Docker on EC2/AWS. Cloudflare, EBS, Redis. Git/GitHub for Source Control. Jenkins for CI. Ruby/Cucumber for testing.

Databases: MySQL

Search: SOLR

Data: Python (pandas, AirFlow, etc.). Redshift/Postgres.

OnForce Platform (subsidiary): PHP on baremetal LAMP (deprecating, moving to AWS).

Our main app is a Ruby on Rails API, with a Postgres and PostGIS database and a front-end built using React.js. It’s hosted in Heroku. We also have a variety of services built in Python that are hosted on AWS.

mindmatters develops software for a variety of customers. Depending on the project specifics we choose mostly Java/Spring Boot, Ruby on Rails, JavaScript, React, Angular 2+, Swift, Objective-C, Android

We’re primarily a Python shop, using Django for our websites. We also have a few services written in Go and have started to build out our front ends using React. We use Github to host our code, Jenkins (for now) to automate our tests, and right now most of our applications and code live in VMs in a Colo just outside of Toronto. We’re in the process of transitioning to AWS. Other common technologies we use are Postgres (primary DBs), Redis (cache and key/value store), RabbitMQ (messaging broker) and Celery (task queue).

React Native, React, Ruby on Rails, Go

Our stack consists of Koa.js, MongoDB, and Angular – because they were the hottest things a few years ago. Now we’re playing with React, React Native, Flow.js, and Postgres – because Postgres is cool again :)

Tech stack varies from team to team: PHP, React, Java, Node, Scala, Objective-C, Go, etc.