Make your MVP in whatever language you know best. Don't chase after buzzwords or trends.

I personally use PHP, mySQL and Redis with nginx proxy, cause I know these the best.

Probably nodejs would be a bit faster, but then again, I would probably make 100s of mistakes, not to mention god knows how many bugs, because I'm not 100% familiar with the language.

C on FreeBSD on EC2.

Yes, the dynamic parts of the Tarsnap website are written in C.

Haskell & Elm. Deployed to AWS with NixOps. Persisted with PosgreSQL and Redis. Code hosted in either Bitbucket or GitHbub. Tasks managed with Trello and email. Occasional sync meetings over appear.in or Zoom (I travel).

You might find some interesting answers at https://stackshare.io/stacks

Started with Python + Django + MySQL, hosted on PythonAnywhere.

At some point, decided to rewrite the project from scratch in Clojure using MongoDB, since Clojure was much better suited for solving the problem in question (modelling the grammar of a natural language - https://www.pealim.com) and MongoDB was better suited for the constantly evolving grammar spec. The rewrite took around two months and I believe that it was the right decision, though I still miss some of the things that Django provides for free (like the admin interface and user authentication).

I also use ClojureScript + Reagent, though not yet on the user-facing parts of the app.

On https://www.stackpair.com I'm using Go, Rails, Redis, Memcached, Minio, Sidekiq, Postgres, and Kubernetes on GKE.

The iOS app is Cordova: https://www.stackpair.com/apps/ios

For storage and backups I use Hubic and Rclone. Hubic is the best deal I've been able to find for LTS: 10TB for €5/m.

We [1] use a Laravel back-end for the main system, hosted on autoscaling EC2 behind a load balancer. Our front-end web application is built on Angular, running on S3 behind CloudFront. Since we process a lot of data, we use background jobs (with SQS as a broker) to perform our analyses. The actual data processing and wrangling is done in Python.

We have released some parts of our systems as open source projects [2], [3], [4].

[1]: https://odysseyattribution.co/ [2]: https://github.com/code-orange/telemachy [3]: https://github.com/code-orange/jot [3]: https://github.com/code-orange/statuspage

We sell diagramming libraries, most notably (by sales volume) a JavaScript diagramming library: https://gojs.net

Our stack is: we don't care. One of us spun up a couple AWS resources and a windows machine with IIS because that's what he knew how to configure the quickest. It seems like it would be a waste of time to spend any more time thinking about it until we have a real need.

We have some orders database stuff we wrote ourselves ages ago with SQL Server that hasn't needed significant changes in 10+ years.

In other words, to us, the stack is whatever makes itself disappear the soonest so we can work on the actual product. Nothing fancy, nothing new, nothing changed for the sake of it.

If our product touched the stack more, we'd spend more time on it, but only insomuch as it was the product (if the product is a speedy website, etc).

Our workflow/cycle is all JavaScript based for the JS product. We push release with a gulp script I wrote.

As an indie founder, I prefer to use Node/Express and React/Redux, hosted on Digital Ocean. Really fast and convenient to build SaaSes and single page apps like:

https://nulis.io

https://helix.startuplab.io

If I don't need a lot of fancy interactive functionality, and am building more of a usual web 2.0 website, I sometimes go with Django/PostgreSQL:

https://fictionhub.io

http://webacademy.io

http://lumiverse.io

For static blogs and content websites, I go with pelican generated sites simply served with nginx:

https://startuplab.io/blog

windows 200, ms access for the backend, ASP (VB) for the frontend.

we also do java applets

We're not exactly a startup, but a small growing data science, analyst, and engineering team in a bigger company. You name it... but a typical data and web stack.

OS/Distros: FreeBSD and Linux (CoreOS and CentOS)

Languages: Python (Data Science) & Javascript (Front End)

Frameworks: Flask, Django, Angular, React, Bokeh, Tensorflow, Scikit-learn

Container Services: Docker, Mesos/Marathon/DCOS (currently testing Kubernetes in GKE - Google Cloud)

Databases: Redshift, Postgres, Cassandra/Scylla

Deployment Tools: Jenkins, Github, Gitlab (different team)

All running in AWS deployed through CloudFormation and Salt.

There's even a Windows Server 2016 instance thrown in there for good measure running Tableau. That's the most reliable part of our stack. </rolls-eyes>

We use Elixir, Go, C++ for backend and JS, Java / Kotlin, C# for frontend. We also use Postgresql, Rabbitmq and Redis.

I run a development shop in Australia and work with a lot of startups to build their MVP. This puts us in a position to recommend our preferred stack:

- Django backend

- React frontend

- Native mobile iOS/Android OR Xamarin (depends on project)

- PostgreSQL

- AWS (Elastic Beanstalk) OR Heroku

- S3

We're building/selling "enterprise" software.

Multi-tenanted single codebase supporting both SaaS and self-host (Windows, Linux, macOS).

Stack:

- EmberJS front-end

- Go backend (static binaries that embed EmberJS GUI)

- MySQL database

- AWS EC2 pulling Docker images from Docker Hub

Python, Django, Go, Lambda, ECS, EC2, TS/JS, React

Not sure we qualify as a startup anymore but our stack is Kotlin + Gradle + Kubernetes on GKE.

Definitely the best stack I have worked with thus far.

https://DNDEmail.com is do not disturb for your Gmail.

We use Python on Google App Engine. Google's NDB datasource.

The Chrome Extension is written in JavaScript.

Wordpress on wpengine.com for the front-end brochure website.

I've written about how to simplify your MVP stack[https://dndemail.com/2018/01/30/how-to-simplify-your-app-pla...] to speed up launching.

We use PHP. PureScript Haskell Postgres :) all on kubernetes atop AWS.

Elixir (Phoenix) in AWS Fargate.

Plain Ruby + Sinatra+ Puma + MySQL (ConnectionPool) + Sidekiq on Redis for the back-end. Sinatra/ERB for low-traffic sites, and ReactJS on S3 for more traffic on the front-end. I always like to err on the side of common denominator, rather than adding as many 'currently hip' tools as possible. Every time I try new things, it eventually brings me back to this set of tools.

At Shelf [1] we use:

Front-end: React, Redux, Vue.js, Meteor.js. Served from S3 via CDN (AWS Cloudfront)

Back-end: Node.js in AWS Lambda with AWS API Gateway, also Node.js in Docker hosted on AWS ECS, spot instances

Storage: MongoDB (on mLab), Elasticsearch (on Elastic Cloud), S3

Other: GitHub, Circle CI, Terraform, Jest

[1] https://shelf.io/

For anyone here interested, there's a website that has a nice UX for this: https://stackshare.io/

What I like about it is you can add open source projects to your stack, not just SAAS services. And also, you can split your server-side stack from your personal tools.

Meteor + React + MongoDB got eddtor.com really quick out of the door. But after 5+ years of maintaining my shipped products (I'm a freelancer, ME-JUST-ME kind of dev), my absolute happiness in customer service & maintanance was the most boring stack of all: PHP + HTML + JS + MySQL/MongoDB. Vanilla FTW.

My present client has ASP.Net/SQL Server/Azure.

Not the greatest fan of Azure, mainly because of the admin portal, but apart from that it's been good.

Constantly get told by their clients that we do everything much faster than other SASS providers they work with, like weeks where others have turn arounds of months.

Backend: Java (phasing out), Go (phasing in), Postgres, Redis, all on Ubuntu EC2's.

Frontend: JS (TypeScript/ES6), React, ReactNative, SASS, all Webpack'ed (except RN).

I think it's a fairly light stack but am happy with it. I would use this as the starting point for pretty much every project.

We are doing live video streaming, mostly Java and React.

Our backend is running on Kubernetes in Google Cloud. Streaming servers are hosted in AWS, but we are preparing to move to dedicated servers.

We also use Consul for service discovery and statistics for streaming servers.

(serious) hobby project: beanstalk, vertx, java, dynamodb, elasticache. Frontend: Kotlin.

We use Laravel for the backend and VueJS on the front end. Forge/Envoyer for deployments.

Amazon S3 for storage, db/redis for queue processing.

Great setup, a lot of the headache is taken out and lets us focus on the development aspects of creating software.

Backend: Python, Go, Java

Mobile development: Android and React Native

Database: MySQL and PostgreSQL

Redis and also RabbitMQ.

Rust on Linux with Cassandra, the strong typing without a GC is a boon to stability and performance (my own sanity). Cassandra is fantastic, looking forward to using Scylla at some point.

As a data company specialized in real time statistics for combat sports, we've built an API with Node.js + Hapi and MySQL. The front-end was developed with Vue.js.

Rails monolith, jQuery for some user interaction (new features are starting to use Vue.js). Hosting on Linode. Capistrano for deployments.

Nothing special, but it gets the job done.

Erlang in the Backend on DigitalOcean. React/immutable/requirejs/bootstrap in the frontend.

The integrations with payments and similar are Java on AWS Lambda.

Node and React/Redux, both with TypeScript. Starting to wish I'd learned PureScript so I didn't have to make do with Ramda for scaling.

Server-Side:

- Python with Pyramid

- SQLAlchemy with Postgres + Cassandra

- Celery with Redis

- Swagger

Client-Side: Mostly React, React-Native

Java (SparkJava Web Framework), PostgreSQL, Redis, Angular 4, S3 for files. Have also used Spring, Jersey, SQS, MongoDB in previous projects.

Context:

https://fibery.io - Work management platform for SMB

Stack:

Clojure

PostgreSQL

Kafka

React

Javascript

Backend:

  - Go, NodeJS
  - Redis, MongoDB, Tile38, Neo4j
  - GKE
  - Traefik

  - React-Native

i'd like to see this question answered only by companies grossing over $100 million and less side-dev passion projects.

Elixir, React, Postgres hosted through Heroku.

I use Go + MongoDB. Hosting via Docker/Kubernetes in GKE. Gitlab is used for VCS, CI/CD and issue tracker.

Python/Django, PostgreSQL, React, EC2.

Using postgre, redis, FeathersJS, Nuxtjs, and VueJS. The near real-time updates and sever side rendering is great.

Python, Django, Postgres, Cassandra, RabbitMQ, Redis, MySQL, Nginx, HAproxy, Elasticsearch, Spark, React.

Python, Flask, SQLAlchemy, sklearn, numpy, Amazon Elastic Beanstalk, Postgres (on RDS). PowerPoint ;-)

Node.js / Express, Nginx, RethinkDB, Docker, tiny bit of Go. Preact / hyperscript frontend.

Python Flask, SQLite, some front-end framework that is available at the time, Linux Digital Ocean

Backend - Golang

Frontend - React app

DB: MySQL

Backend API servers: Golang, Python, Redis

Frontend Web Servers: PHP (Laraval), JS (React), MySQL

ReactJS front-end, Grails back-end API with a PostgreSQL DB deployed on AWS.

Ruby, Scala, Postgres on AWS

Ubuntu, node.js, MongoDB, Mongoose, express, RE:DOM, stylus, nib, pug, ...

Company - www.LetsEnvision.com Stack: Swift, Obj-C Python C++ MongoDB

SQLite, ASP.NET Core, jQuery, Bootstrap. Kinda boring but works

I use Stackoverflow :)

PHP (Laravel), JS (Vue + Vue Router + Vuex), MySQL.

Keeps things simple.

Python, Flask, Tensorflow, Keras, Amazon MWS, Boto

for my food site I use nginx as a proxy, Go for the server and Postgresql as the database. I deploy to digitalocean

for what? if its for analytics? we use Panoply and Chart.io sources are all over the place

undefined

- java

- dojo

- IE11

- jenkins

- we are not a startup :)

Backend: Node.js, SQL Server, Redis.

Frontend: React, Redux, Bootstrap via create-react-app.

Rails, mongo, elasticsearch.

Microsoft Products all the way... only way to scale.