Which stack for prototyping?

> As a former developer, I have had countless project ideas and choosing the tech it's going to be written in has always been a [unnecessary?] long topic, often leading to procrastinating and giving up on the idea.

And here you are, posted the question on HN and doing it all over again :)

The answer is the tech stack doesn't matter all that much.

All you care about is bringing ideas to life and python is versatile enough to do anything, so pick that.

The best stack for YOU to prototype is not the best stack for ME to prototype.

It's whatever you are most comfortable in, and can move the quickest.

It's the stack where you don't have to re-learn how to do things you know are possible.

So with that in mind, it's probably not the latest and greatest technology (except if you happen to have been living and breathing it for the past few years). It's probably got some warts that you don't like but for which you are also very competent at overcoming.

If you are leading a team and need to decide that for them, try to find out which stack each member has gotten the most done in (in current or previous job), and average it across the team. It might be helpful to set expectation that this is not the most glorious technological project of their lives but that the goal is a rapid developement project with the goal to replace parts with something more robust once they get validated on the product/user side.

Whatever backend tech you are most comfortable with and https://htmx.org, which is backend agnostic and has almost no learning curve and requires very little code.

Blitz - (https://blitzjs.com/)

Blitz is built on top of Next.js and gives you postgres for free, in addition to auto-generating CRUD routes on schema changes. It's trying to be like Rails.

I've used Next.js with firebase for multiple prototypes.

For me? Just Go.

Building a service? Go.

Need a light UI for the service? Go + Go html templates.

Need a command line tool? Go.

Building an interpreter or transpiler? Go.

That’s just me though. The reason that’s my answer is I’ve been writing a lot of Go lately.

Answers I might’ve given at another point in my career:

- Rust - I’d still reach for this but I find it a little slower to work in for prototyping.

- C#

- F#

- Ocaml

- D

- Pascal

AFAIK laravel 8 -- the latest -- is the only stack to provide auth out of the box

As in

They give you a login screen

When you install an app 'starter kit'

Breeze -- the simplest -- in this example

Downside is you get stuck w vue and tailwindcss as defaults

  curl -s https://laravel.build/example-app | bash

  cd example-app

  php artisan migrate

  composer require laravel/breeze --dev

  php artisan breeze:install

  npm install

  npm run dev

  php artisan migrate

Be careful, prototypes sometimes become products. So, pick something comfortable for you, but that you could grow into a product with a good enough scale.

I like Rails on the back-end (or simpler Ruby-based frameworks like Sinatra) and Vue or Nuxt on the front-end. I have stuff in production with these and they progressed very well from prototype to production.

On the frontend, buy a HTML theme on ThemeForest or similar. Your goal is very quick prototyping and visual design decisions will slow you down. These themes aren't the best code, but they look good and come with tons of layouts and components you can mix and match.

If you're already very comfortable with Python then that should be your first choice for the backend. You can be flexible with the framework though - Flask[0] is also popular, or you can try one of the new async ones like FastAPI[1].

For the frontend I would suggest htmx[2]. You will anyway need to do some html, and htmx will save you the trouble of learning a JS framework.

0. https://flask.palletsprojects.com/en/1.1.x/

1. https://fastapi.tiangolo.com/

2. https://htmx.org/

I put together a one-day hackathon project with Next.js on Vercel and Supabase. Supabase is a “firebase alternative” that gives you auth and a Postgres database in a single package in like two clicks. You use row-level security to define what permissions a user ID has using Postgres policies. If you’re a front end weighted developer this is great because you can pretend “there is no backend”, although with Next you can still write server side code that bypasses the row level security. Now, there’s issues with Nextjs/Vercel like “how do I run a job queue?” (Seems like you need an EC2 box somewhere else) that are unsatisfying, but for 1-hour productivity I don’t think you can do better.

Different stacks for different people.

I prototyped an app with a MERN stack. Mongo, Express, React (CRA) and Node. By no means was the backend performant, and for this app, I had no reason to use document database instead of relational, but because I know how to write with mongoose, I chose mongodb.

Now that the prototype is done, I'm looking at other languages and frameworks for the backend such as Phoenix, Hyper.rs or asp.net core. If I want to be lazy, I'll just convert the mongo queries to Postgres and be done with it, and then move my CRA React App to Next.JS.

If you are already comfortable with python then choose django. Learning a new framework will take time, which will be your case with django. You don‘t want to learn a new language too.

Personally I stick with Node (Express if it's a web server). Next.JS is cool but it's a bit too magical for my tastes, at least when hackability is the key priority.

Usually I end up adding TypeScript into the mix, even for prototypes. However, I'm pretty comfy with the configuration side of that (webpack, etc) so it isn't a huge time sink. If it is going to be a huge time sink, you might try Deno instead. It has Express-like libraries of its own.

The choices really do depend on exactly what it is you're making. I normally use some combination of python and htmx. I'd be using very different backends if I was building a distributed storage server, a chat server, a blog, or all kinds of other stuff. Mostly I'd be using htmx on the frontend though.

Is your project mostly database admin? The django admin can probably get you something useful fast. Is your app less database driven, or you need more flexibility? Flask is a good bet. Dealing with "live" data (chat apps, etc)? An asyncio project like quart or aiohttp might be best, coupled with a database that supports subscriptions/changefeeds. Alternatively flask with server-sent-events and redis might work better. If the project was mostly an API I'd likely use fastapi.

You can combine a lot of these servers in the same app with wsgi "application dispatching", although generally support for mixing asyncio frameworks and traditional frameworks isn't great.

Unfortunately there isn't a one size fits all solution right now, some frameworks will do some stuff better then others.

For web stuff, my personal go to choice is Node.js and some templating engine, like Handlebars. I used that on several occasions to quickly hack together stuff and see what an actual integration with some service looks like. Then i move straight to Java. How does that defines as prototyping, i'd leave for the semantics patrol.

Reiterating "personal choice."

I like to keep things simple so over time I removed stuff from the things I use and kept the things that has the largest reach. So what I use to prototype is very similar to what I use to deploy:

* Typescript + Vue on the front end (with nuxt) - NO SSR but nuxt precompiles the pages for me so I don't get the SEO hit. Front end can be served from any CDN basically for free.

* Node for the rest API with a custom, very simple and declarative framework that wraps HTTP, this only replies in JSON (also typescript)

* ArangoDB for all database needs. Has key value store, document store, graph store, so best of all worlds. I can use it like a RDBMS where it matters because graphs support relationships so no data duplication AND no need to normalize.

I can basically do anything with those, from quick prototypes, to a very low traffic website to serving millions (managed k8s, horizontal scaling comes into play then).

The entire backend in Rust, using actix-web framework and async libraries for postgres and redis.

You're not going to rapidly prototype anything with Rust for your first 12 months working with the language, depending on your motivation and your ability to write missing parts for security middleware. However, once you've gone through that, you can be just as productive with an async Rust stack as you can with a Python one. Your prototype will also be ready for the "no time to refactor" mandate that makes it your production system. Actix-web framework and async libraries for postgres, redis, and rabbitmq are all mature and well-documented. I realize you said quick prototype/MVP, but all of this comes at little additional cost once you know how to adopt and integrate quickly.

If I were writing a big web-app I'd probably use either golang, or Perl.

I'm not a fan of PHP, I've never used any of the python frameworks, and while I can use Ruby on Rails it would usually not be my first choice - not unless I was building a simple CRUD application.

Perl gives me the amazing CGI::Application framework, a lot of libraries for integrations, and a standard approach to writing tests.

Golang is the new-hot, it's good for writing servers and services, also has a testing-centric development approach, good support for templates and a simpler deployment approach than most dynamic languages.

Still, my preferences tell you little except what I can/will use. The answer is usually to always pick the framework/think you're most familiar with OR the thing that you want to learn next.

I think you've already mentioned all the obvious choices. Out of those I would probably discount Node if you want a really quick prototyping experience. Nest/Next just aren't on the same level as the others.

One of the best things you can do is use Postgres as the backend.

Recently I really enjoyed using Elixir with Phoenix for this, it replaces what Rails use to do quite nicely.

For frontend I try to stick again to just HTML and Vanilla JS, if I know the frontend will be more complex then I go straight to Elm

For the design I built MVP.css for “drop in” styling without having to learn a CSS framework:

https://andybrewer.github.io/mvp/

I'm surprised no one has mentioned Pharo with Seaside. I'm not sure how you would make the iteration cycle shorter than editing code in a live Pharo image and using the image itself as the data store.

Depends on the type of proof-of-concept you're building, e.g., website with lots of user interactions or a data pipeline?

Either way, I use python (FastAPI) and vue.js to keep the front-end and backend separate. That way, if you're working in a small team then responsibilities are easily separated and helps with scaling too, e.g. when you reach 10k users. There's also a great range of libraries available so prototyping is quick on both ends.

As for deployment, I use docker and a digital ocean droplet. That way, you can deploy easily as and when needed.

Backend: I would stick with Python, but modernized with some bit of dataclass and typings.

A very tempting alternative is Golang, where it's fast build time and light syntax makes it a good candidate for prototyping.

Also, I know many do not like it in this forum, but a document-oriented database such as MongoDb will save you a lot of time when dealing with json style documents.

Frontend: Here, I feel Angular can still deliver, once you have climbed the steep learning curve, the most important being to use a toolkit such as Bootstrap, which is a huge time-saver.

The best tool is one you already know

I would start with separating the frontend and backend, as some others have suggested. I would probably use react but could try svelte or vue also. In the start you can mock the backend or have a memory-kept version of it.

For backend (the api) I would go for c# or nodejs (maybe with nextjs). I might combine this with a serverless solution like Architect.

https://github.com/architect/architect

I won't be the most popular person on hacker news for this but check out bubble.io for the front end and then use heruku(free tier) + python(flask + fastapi, etc) for the API.

With this stack you can quickly build a API, connect it to bubble and show people your idea in a way that's actually working. Later on you can move all your API data off bubble and replace the front end with whatever you want.

I found it the cheapest and easiest way to build something very quickly.

For me it's Ruby for shell scripting, Elixir+Phoenix for web apps VIM mode (of whatever IDE or editor) for editing.

For a fast prototype, picking a language that has ready to go api examples in your space is the best bet:

Twilios: https://imgur.com/a/iACVPvU

Stripe: https://i.imgur.com/esOq0dB.png

ETC

Ruby on Rails, people!

Svelte + Hasura (+ Keycloak for auth)

Skip the backend unless you absolutely need it. Saves so much complexity, time and money.

- Backend

-- Ruby: Roda + Sequel + SQLite (or any db)

- Frontend

-- Node: SvelteKit + ViteJS + TailwindCSS

- FullStack (monolithic)

-- Ruby: Roda + Sequel + ViteJS + TailwindCSS + SQLite (or any db)

Find a bootstrap visual editor and use that to mock up a Web site. Make sure to use one with lots of blocks you can just drop in the page.

Use framework7 with Vue for a mobile/webapp. For a more complicated site build it with django or php if you might want to hire cheaper devs in future.

Frontend: NextJS DB: GoogleSheets

Google Sheets allows you to see all your data immediately and setup takes 5 mins. Does it scale? No. This will ensure that you throw away your prototype and use your learnings during a rewrite in case the project becomes more successful.

I like feathersjs for the server/api since I find service-oriented thinking to mold well to most projects and it scales well, plus easy integration with almost any database.

Re: frontend, I like vue/nuxt plus Vuetify as a component framework

Vue: because it is easiest to pick up and has great dev tools.

C# with ASP .NET Core (because i am most comfortable in .NET)

cloud: Azure (easy to use, has in built auth), and you can limit your credits, so you won't end up with crazy monthly bill like AWS

Safe stack iff I don't ever want to put it into a production environment for work. If it's my side project then I would still use it.

Why because at the moment I like F#.

For web: Next.js + React.js + Tailwind CSS + MongoDB!

I'm using Nest for mine which allows me to stay in the JS ecosystem, so far I love it, it supports pretty much all I need out of the box.

Python (Flask) and AngularJS/Material 1.8

I use python/flask on GAE or express js on firebase functions. React for fe. (In all cases, no managed instances.)

Clojure/Ring + Datomic + React

Extreme minority opinion: Lazarus/Free Pascal

Nest with next.js for sure. With apollo as communication layer the frontend storage is resolved as well.