If you were to build a web app today what tech stack would you choose?

.NET 8 for the backend, and then blazor webassembly for the front end if it's complicated, or just boring old server side rendering with htmx if it's not.

I've seen a lot of projects fail/struggle in golang (package ecosystem is still missing a lot of basics imo) or nextjs (very buggy).

.NET has been my secret weapon. It's boring, works really well, has a good ecosystem and asp.net is really well thought through and you can go as "deep" as you want with middleware etc. Plus performance is extremely good, as is the deployment story with docker these days (having to use Windows server with .net Framework a few years ago was a nightmare, enough to put me off, but in .net core Linux is a first class citizen now).

Also the IDEs are great these days, especially rider.

You mention it's a passion project. If technology is the center of that passion, then pick what you're passionate or curious about!

If not: the tried but true Rails + Postgres.

Add more things only when needed. For example Alpine.js if a bit of interaction that's not covered by Rails' Turbo. If the need for background processing arises, bring in the good_job gem, and there may be no need to deploy it separately at first.

For hosting I'm not quite sure these days. Heroku may be on life-support, but its feature-set covers most basis.

Just had been thinking about this today, the current state of web development is making me seriously depressed.

I would pick what I'm most comfortable with, a simple monolithic Nest.js application running Fastify, with Postgres or SQLite, Dockerized, hosted on a predictably-priced host like Hetzner, and Ansible to automate everything. I know that stack will give me plenty of headroom until I eventually need to scale differently.

Front-end is still React, which has a massive ecosystem, and I feel like I can do _anything_ with it by just bringing in some dependencies, if it's a passion project then I want to deliver features fast, React allows me that.

I feel like a dinosaur, edge, workers, cloud functions... I'm familiar with none of that magic, there's probably a whole universe of amazing new ways to build for the web I'm sleeping on, but at that point I don't even care really.

This depends on your goal: Are you trying to build + finish a project, or learn a new skill? I like to separate these goals, or otherwise try to scope projects very narrowly.

For the former, I tend to reach for the tech stack that I've spent years working in and can very quickly spin up projects in. This is heavily specific to your background, but for me:

- Frontend: React, vite, react-router, Chakra UI.

- Backend: Node.js + Express

- Database: PostgreSQL

- Scheduled jobs/ML/data processing: Python

- Deployment/Infrastructure: Docker, docker-compose, AWS EC2 or Lightsail, Digital Ocean droplets, Netlify, Render

For the latter, there are lots of potentially better options, whether that's server-side rendering, serverless functions, etc. (Next.js, fly.io, supabase, are a few examples) and again depends on your industry.

My current side project is using python aiohttp and htmx. The main plus of Python is that it has a lot of machine learning functionality but the truth is almost all of that is used in batch jobs and if I did anything computationally intensive serving a page I would have to farm the work out to another process. I have no trouble maintaining Python I write but it seems to always fall apart like Jenna blocks when I hand it off to somebody else.

If I had to get more people involved and have it scale I might go to Flask but might also go to a Java-based backend as it really has the best ability to use threads and parallelism.

As for HTMX I like it but I think there could be something similar but a little more feature risk, for instance my app has a lot of tables and tools that make it easy to add client-side sort buttons would be nice. If I had more people working on it I could see using a react-a-like system as well.

The database is arangodb which I love for rapid prototyping but if it had to be really reliable the first thing I would look at is postgres.

The answer to this kind of question is always "whatever you're most comfortable/productive with"

For me personally, I've been working on one that's pretty app-y and used Postgres + Deno + React/MobX (built with esbuild)

I'm very comfortable and happy with TypeScript, so I like having it on both ends (especially because I can share types between the two sides of the wire). And Deno and esbuild make the tooling story really simple and no-nonsense on the back and the front respectively, while being less opinionated than a framework like Next (I like Next for other things, just didn't choose it here)

LAMP.

It can easily be maintained by a single developer. Scales well enough for a decent number of users. Huge ecosystem of components. Easy to deploy to literally any web host. Wide variety of front-end systems.

If you need to scale, it can do that. Developers for it are plentiful. But you can always rewrite it in the flavour-of-the-month framework when you hit either scale or money.

Django with HTMX + Alpine on the frontend. Deployed as Docker container on a cheap VPS. It's boring, time tested but by Jove, does it get the job done fast.

I'm building a B2B2C marketplace in my free time and I'm blown away by the practicality of this stack. Due to longevity of Django, every problem I encounter is just a search away. DRF makes it dead simple to add REST APIs. The Admin panel is a golden cherry on top.

Django + HTMX + SQLite or PostgreSQL Hosted on a virtual machine.

... Or the stack you're most efficient/ effective in. A short time-to-market is most important for learning. If you don't reach an audience, your project might bore you soon. Tech rarely is the holy grail to success.

Elixir/Phoenix + Postgresql. Maximum comfort, minimum chore.

For frontend side, if i can get away with minimal js, i'd go that way. If not, highly depends on team and target interactivity. If it's just me, i'd go with LiveView

Rails. It's all about developer comfort. ruby as a language is a delight to work with. Rails as a framework has all the features I need and then some more. Postgres as the database of course!

For a more nuanced viewpoint than "This is the tool I am most familiar with" (which for the most part is both the right answer for that person, but probably not for you), see the MDN articles starting at https://developer.mozilla.org/en-US/docs/Learn/Tools_and_tes... and reading down through the next few chapters.

I'd write it in Lazarus/Free Pascal, compile it to WASM[1], and do whatever hacks I had to do in order to push it through the internet into a web browser.

There's nothing even close to the productivity we had back in the days of VB6/Delphi to be had on the web, ever. The closest we're going to get is a pale imitation.

[1] https://wiki.freepascal.org/WebAssembly

SvelteKit + Supabase to do it quick and dirty. Since I am not the best programmer out there (my day to day job is product owner), it allows me to actually finish my projects and validate them with the market within days instead of months.

I can totally see how a senior fullstack dev would have a completely different approach though.

I just went through this and settled on Vue, TypeScript, and Vite for a rewrite of a PHP app. I can recommend that stack.

Vite and TypeScript were new to me. I'd briefly used a older version of Vue for something. I currently deploy to Vercel, but don't have any Vercel dependencies.

I used Phind, ChatGPT, GitHub Copilot extensively in order to understand the "AI pair programming" experience. They were helpful for suggesting solutions and helping understand mistakes. Just to set expectations, the flow was less "problem→solution", and more "problem→try this→iterate→try this→iterate→solution".

I might be the only one in here with an answer like this, but PowerShell and the Pode framework. I am super productive with it, as much so as in any other language, and it plays nice with the rest of my stack (Tailwind, HTMX, SQLite.) I can leverage the .NET framework and C# libraries when I need to and can iterate quickly. All of this runs on the latest version of Ubuntu LTS. Obviously, this won’t work for everyone but for my purposes I haven’t been able to beat it and it makes me happy.

Depends on project requirements of course and it's been a little while since I used them in anger, but sounds like Rails and Postgres are still going strong so I'd probably pick those. If something like React was strictly necessary I'd use React plus the most vanilla TypeScript stack, but I'd use only Rails' built-in stuff if at all possible. I don't know exactly about hosting but I'd probably go for something like Render or Heroku.

Django/flask/qaurt (depending on what features I need), htmx, and any more complicated stuff (client side terminal emulator, client side text editor) wrapped in individual web components. Probably use sakura.css to start with for css.

SvelteKit + hosted Postgres (supabase, neon)

Very fast to get going and nice developer experience. Love jamstack style hosting. Scales from simple static site generator that is free to host, to live APIs/dynamic pages, and back again without changing frameworks. Can make beautiful pages that load in 100ms and 30kb.

Currently using tailwind css because it also compiles (like svelte) and only ships what you use to the client.

I built my business on Rails/SQLite/Sidekiq+Redis.

Hetzner (bare metal) for hosting. Bash script for provisioning a server. Vanilla JavaScript only when necessary. Tailwind for design. nanoc for generating a static site.

If I were to start again, I'd pick the same stack again. It just works and gets out of the way.

For internet facing webapps where infinite customization of html/css is important: Jakarta EE: Java 17/CDI/Quarkus for the backend, HTMX for the frontend. Quarkus is now standards based and has a large community. Java executes at near CPP speed but with memory safety. Java has the literal best debugger in the industry and also the combination of CDI and Mockito make writing true unit tests easy and fast. It literally has everything.

Honestly though, the vast majority of webapps I implement are "boring" and the technology behind them needs to be boring and focus on productivity and maintainability. For this I usually select JakarataEE and JSF/Primefaces. Component based frameworks like this are stupid easy to slap together forms and business processes for internal webapps.

Something boring, well documented, and widely used. The more boring the better. I'd avoid hotshot stacks like the plague because they are usually immature and tend to change quickly.

Ideally, I'd pick something that has OpenAPI as a first class citizen or code generation, including validation.

It would depend whether the web app is a "dynamic website" or a "super interactive app that happens to run in a browser".

For a website, it'd be Go + HTML/CSS (sprinkling JS where needed). Here's why: (1) Code will "just build" years later (2) Deployment is stupidly easy -- just build to a single binary with all resources embedded (3) Everything about the stack is stable and easy to reason about. Though perhaps not exciting.

For a "web app", I feel there are no great options. The half life of the JS ecosystem is about 5 minutes, so whatever you start with will be out of fashion shortly after. React has had some staying power, though isn't without its flaws. I generally feel like most "web apps" could actually be websites though.

Two recent projects I wrote in C++20 using my own HTTP library. Only dependencies are a JSON library and a HTML template library (only used in one project). For these projects I used my own Postgres C++20 library.

Another recent project I did in mostly pure Java, with only a third-party library for SMTP email sending, and a library for using HTML templates.

IDE is VSCode with clangd as linter, and gcc as compiler, and CMake as build system. For Java, I use the RedHat VSCode plugin.

Frontend in pure TypeScript, with an icon library.

Challenges I encountered: - Statically checking data structures between frontend and backend. This needs code generation. And there was a lot of code repetition for shared data structures between front- and backend. - More database abstraction would be good.

Other than that it all runs great.

.NET 8 on my mac using Rider.

It’s not the .NET Framework you might remember from the 2000’s.

I would choose Remix based solely on my assessment of the integrity and personal character of the people I’ve met who use it, which I suspect is similar to those who created it.

Elixir, Phoenix (+LiveView), Tailwind CSS and PostgreSQL. :)

Frontend: Angular or Vue, deployed on AWS S3 bucket + cloudfront (for https)

Backend: AWS Appsync (or AWS API Gateway) integrated with AWS Lambdas written in Golang. Authentication through AWS Cognito. DB: anything serverless from AWS (Dynamodb, Aurora etc.)

This way the app would be 100% serverless, no need for effort to scale it or to maintain the infrastructure (apart from automating the ifrastructure through AWS CDK).

I loved Drupal back in the day, but at some point (D8+, part of it moving to Symfony), it became too difficult to manage and for me personally to keep up with.

But I believe that, in the early days, Drupal made excellent foundational design choices as a framework, and if you used it's APIs in your custom module development, then, generally speaking, you would have a secure website.

But now, D7 is approaching EOL, and I absolutely don't want to migrate to the latest flavor. D7 has been rock solid for a decade, and I have no desire to chase the latest fad.

I wish that there were a stable, monolithic solution that is simpler to setup (as in including everything, including database, webserver, SSL certs, etc.) that just worked and was extendable and overridable programmatically, in the same way that Drupal was.

Modern web stacks have become a bucket of Lego pieces that seems ok if you are an expert in everything and know how to put everything together exactly. The problem is, most people aren't experts in form handling, login and authentication, media handling, caching, etc.

depends on the goal:

if the passion is to learn some new tech then well, there are lots of options, i'd pick something that i haven't worked with yet.

if it is something where the passion is in the content, i would use the same old stack that i used for my last few projects. in my case that is aurelia+custom backend which is a reusable object storage and user management platform, where i didn't need to add any project specific features for some time now.

if i could not use that backend, i would pick something that makes it easy to manage objects through a REST API.

if i had to evaluate a new framework then the main thing that i would look for is the ability to minimize or avoid any dependency on build tools.

unfortunately, with the rapid evolution in frontend frameworks there is also a rapid evolution in build tools. that just adds extra effort to maintain a site for more than a few years.

without buildtools getting in the way i can maintain a site with minimal effort, and i know it will still be running in a decade from now.

I use Typescript and Python. Usually Svelte or Vue and Django. For Async components of the backend I write components in Go.

Backend in Django Rest Framework. Postgres as db. Frontend Typescript and React. Deployment with docker compose on AWS.

Elixir, Phoenix (with Ecto and Postres), LiveView.

Functional programming, pattern matching, and immutability make life a lot easier.

depends on the app but Laravel + something.

It's all built in, you can buy packages that implement most SaaS features out of the box, authentication, 2 factor, all the crap you need is rolled in as packages.

I would stick with something like Orchid for admin type CRUD apps as there is ZERO html/js knowledge required.

for a public app - I would still use Orchid on the backend and then on the frontend use something simple with blade templates and controllers.

PHP is a lot better than it was, Laravel developers are easy to find, the stack is very well understood, and it's flexible enough to build whatever you want.

EDIT: I just wanted to add 99% of "apps" are not retail facing but are internal apps or business to business type apps that solve a specific business niche. For that, I only care about how fast and easy is it to stand up and implement that specific business logic.

I built this site recently with Blazor: https://gpsoutage.com It runs completely on the client and is hosted for free on Azure. There is a lot of support for Blazor and as a .Net backend dev, I didn't have to learn too much front-end code. I'd definitely choose Blazor again.

I've really been into what I call the "HAG" stack: HTMX, Alpine.JS, Go.

It's simplicity has been a fresh of breath air. I love Go and being able to use it for almost the entire web app is amazing. I am excited for the upcoming router enhancements Go has proposed, that will let me move off Chi router. I try to stay as close to the std lib as possible. Though, the `templ` package is amazing and I very much will continue to use it when possible.

For my database I use `libsql` by Turso with server mode.

As for deployment, I just dockerize the app and the database then run them as two separate components in a Docker App.

Makes it a simple and easy to develop and deploy updates.

I used SvelteKit, but it would be nice if there was something like rails on top of SvelteKit that brought database connections / models, admin screens, etc.

SvelteKit is the best combination of front-and-backend in terms of performance and developer usability that I've found.

Go for backend, HTML template files for frontend + Alpine.js for reactivity. Probably custom/classless CSS as I'm falling out of love w/ Tailwind. Probably would deploy on EC2.

If I was trying to learn something new, I'd experiment with solid.js or htmx.

Last thing I built is using SST for some lightweight recurring TypeScript lambda functions + DynamoDB for data storage. Plus a very simple one-page Remix + TailwindCSS frontend because deployment of that through SST is a breeze as well. It is the stuff I know and can easily handle.

For anything new, I'd try Phoenix to see what I can achieve with Elixir and a non-React/Vue frontend.

Depends on business scope, growth model etc. My default option is Java/Spring Boot/PostgreSQL for BE with HATEOAS API, Typescript/Angular SPA for FE if personalized experience is required. If it’s about just serving some almost static webpages, then some SSG+headless CMS with a bit of vanilla.js.

Choice of stack is simple: it may not be the best in class or fancy choice, but it’s close enough, allows simple infrastructure setup, quick start with rapid iterations and easy to go from 1 dev setup to a team. More importantly I have a lot of experience with this stack, so I can focus on business rather than on learning new technology.

Loving seeing so many Sveltekit + Postgres posts! Truly hard to top the dream team.

Sinatra, flask, or Laravel. Something that gives me a direct control over routes and allows me to opt-in to magic when I want or need it. Dynamic language.

Depending on the frontend need, I might go with straight server rendering static pages. So often the big stack of rendering contexts and HOCs and blah blah blah just gets in the way. Rendering a view shouldn’t be difficult, and progressive enhancement is easier starting from strict HTML + well structured CSS.

I love React, I’d be happy to try Svelte… my fear in not doing that would be “when we eventually need it, it’s difficult to opt in progressively” (which is terrible).

Laravel or Rails spitting out Blade or ERB templates respectively. As a solo dev you have everything you need in both ecosystems and you aren't doing 2x the work with a separate front end and back end.

Either one that I wanted to learn or one that I knew.

Which of those depends on whether the focus of the passion was exploration of new tech to make an impact on my understanding of tech or exploitation of existing tech to make an impact on the world.

If it was the former, today I'd probably learn Rust + whatever webapp stack is popular in that language. Seems to make some pretty interesting guarantees around programming and is blazing fast.

If it was the latter, I'd pick rails. Nothing in my experience beats rails for productivity for a bog standard webapp.

I’d use whatever scales best for the least cost.

Go backend. Single binary. Big performance. I’d use Go for as many things as possible until I actually had a need for distinct technologies (queues, redis, etc.). Throw embedded db into the mix and you shouldn’t have any problems for a long time.

React UI on cloudflare pages. Free. Easy.

Postgres. Single node goes far. Great plug n play extensions. Same as with Go I can push this pretty far until there is some serious requirement to do something else.

Deploy on either cheap bare metal or an affordable provider like DO.

I have just launched a relatively straightforward webapp that required a light touch front end with fairly significant data processing on the backend

- Backend: Django (Postgres in production) + Celery to handle async tasks - Frontend: HTML (standard django renderer), CSS, HTMX + occasional jQuery - Deployment: Render

I was already familiar with Python and I feel the language is more than capable to handle the data processing required and with Django I could concentrate on the actual app functionality without diving too much into auth etc

I'd use Ruby on Rails with Hotwire. For building a SaaS quickly, it's my go-to framework.

What you know best!

For me it would be:

*Django* for backend with the built-in templates. No frontend backend split.

TailwindCSS for styling.

StimulusJS for sprinkling JS wherever needed, which is not very often.

Postgres as my DB (although if I'm not integrating Stripe, SQLite will suffice).

Maybe Redis for caching and as a broker for background tasks, if needed.

SvelteKit + SQLite for me. SvelteKit is easy to pick up and their standards make sense to me.

Of course SQLite has limits but it takes a lot of complexity or concurrent users to come close to them.

If it is my money/time then I'll choose Django, Rails or Phoenix.

If it was a big corporate with deep pockets then I'll (or they'll force me to) go with React, Angular etc.

Fishing tackle - much easier to go fishing than to navigate today's stacks and interfaces.

Go Std, HTML + plain CSS + vanilla JS if needed. No build steps.

Just pure ol' JavaScript with a couple libraries.

Frontend: Lit and Tailwind (in reality, unocss, a tailwind runtime that doesn't need build)

Database: indexeddb + some CRDT

Backend: no backend, webrtc to sync between devices without a central server

Hosting: Github and cloudflare cache, the app has a functionality to deploy itself, generating a minified tailwind CSS and if needed, a "SSR" version of it (but without hydration, this is the part of the frontend craziness that I don't wanna get close).

React on the front-end because of eco; Fastify on the backend w/ Postgres. I host React w/ Remix for light-duty SSR, but real work gets done on the backend. I'm moving away from metaframeworks as single solution -- they're easy, but keeping biz logic on the be makes it much easier to swap out fe and better for testability IMO. I'll prob shift over to Solid once / if Start ever ships, else Qwik.

Go + wasm(https://github.com/maxence-charriere/go-app) + IPFS + orbitdb

Personally, I'd go with https://pyapi-server.readthedocs.io

I'm surprised nobody said they'd use [Yew](https://yew.rs/), especially given the premise of this being for a passion project.

Go using the Gin framework. I’d use SQLite until I had a compelling reason not to. Server side rendering using pongo2 templates. Vanilla js and Htmx where appropriate.

I’ve built several projects like this and just started another one and it is by far my favorite stack.

I don’t like spending time fighting frameworks, so I like to keep my stack as minimal as possible. Thankfully the Go ecosystem pretty uniformly shares that ideology.

Instead of thinking about tech stack think about the problem you want solved. Most devs think about tech stack first and so all they do is read from a database and struggle to put text on screen. Then once that climb that mountain their product looks identical to everything else and is limited to putting text on screen at considerably inflated expense.

I started work on a passion project recently and chose to use Next.JS on Vercel. It's new to me and so there was a little bit of a learning curve but that was part of the fun.

Seems super simple to get up and running and let's you focus on the product itself rather than the stack.

Alternative answer: Use whatever you're most familiar/comfortable with.

I've been meaning to try Django (mit Postgres) + HTMX + Alpine + Tailwind for a while, and while I don't typically write a django admin page, https://github.com/unfoldadmin/django-unfold at least puts them in the same box for me to start playing with

For the frontend, there is React framework called refine for building CRUD apps like admin panel and internal tools

https://github.com/refinedev/refine

It has built-in integrations for UI libraries and data providers. You can select your stack

NextJS again!

I keep changing my mind. Part of me wants to use old school tech. But I do like the DX of Next.

NextJS tends to make sites that need JS on the front end. And probably bigger bundles than an old school MVC job. I will take that hit though for some of the positives of working in React and productivity and modernness and community of great work around React.

Rails 7.1 deploy with Kamal to a low cost place.

It would definitely either be TS or Python.

I think I might use Bootstrap but I'd heavily customize theming.

Probably SvelteKit or Vue for the frontend. Most likely SvelteKit.

SQLite or a flat file database for sure.

I think what I would do is use Tornado to serve SvelteKit pages, if I went with Python.

Definitely a monorepo for front and back end. Probably I'd try to do zero server side templating.

I just started trying out Bun and its focus on speed plus broad compatibility makes it an absolute pleasure to use so far. For hosting I haven't started yet but think I might try fly.io with LiteFS as database. Just for fun, I wouldn't choose it for a work project until I've tested it out.

Laravel Jetstream with Inertia + Postgres, for sure. It is the most productive setup I have found for myself as a solo dev trying to deliver a full web app. If it is more like a backend-only setup, an API or sth, I tend to default to Go these days due to the speed and ease of deployment.

If it’s a personal project, I would pick and try out the latest trends that I’ve been keeping an eye on.

I’m planning to try out HTMX + a backend written either in Rust or Go. Since it’s a passion project it doesn’t necessarily need to be out there for thousands of users, so I’ll go with SQLite.

Exactly the same "tech stack" as I used before that term became popular:

    - HTML
    - JS (Ecma Script, not some "framework")
    - CSS (not "Typescript" or whatever, standard CSS)

For backend I'd use PHP. Yes, PHP.

Edit: The same would apply for $job

T3 stack, with bun

(Typescript, tRPC, Tailwinds

Next.js React, Prisma, Zod

Bun)

Client and server in one project and language. All the trendy, still free, easier to use compute instances let you deploy javascript server projects. Many don't support other stacks like Java or Python. Heroku supports python but no longer has a free tier.

T3 stack with MUI deployed to vercel + Postgres (I use supabase) My latest projects are built with it, but I also use a very similar stack at my work so it’s easy to pick it up.

Also, this stack is free if using vercel + supabase until you reach an BIG userbase

Frontend: Remix or Next.js with server components

Backend: ASP.NET Web API (REST). Only calling these APIs from the backend-for-frontend Node code.

Hosting: Everything at one Cloud provider, either Azure or AWS. No SaaS-services.

Database: Postgres

Infra: Terraform or Bicep for infratructure as code, and Docker.

I'm a simple man. Node/Express with probably MariaDB and React. Maybe give Tailwind a spin. Same with next.js if I had the time.

Would prefer go on the backend but language switching when doing frontend at the same time is a bit of a pain.

Yesod/Haskell for the backend, backbone.js for front end. Oracle for DB.

Well, i am currently building a little App for my job that is also a bit of a passion project, well, i am building using the Internetcomputer and the motoko language in the backend and vanilla JS and html in the frontend.

Litestar + HTMX

Litestar + Svelte

SQLAlchemy

Haystack

https://litestar.dev

No extras. Hand written JS, CSS, and HTML. Backend use CGI or for long polling type apps, golang and an HTTP server module. Or Python and its batteries-included HTTP server (but I'm moving away from Python).

Rails + Postgres w/ [1] jumpstartrails

[1] https://jumpstartrails.com

Something that I am good / fast at

Phoenix & its Liveview. Backed by Postgres or even SQLite for some use-cases.

I'm going to be working on a niche search site soon. For it, I'm planning on using PHP, Nginx, Postgres, and Typesense for the back end and probably React for the front end

I've been in love with:

Backend: Golang standard lib, gorilla/mux for routing Front: htmx + tailwind

If i need a database, i tend to start with redis, then sqlite and ONLY if it scale, postgres!!

i cannot answer objectively for obvious reasons. but i am very happy with Go back-end, Quasar front-end, JSON for message formatting and MariaDB for data storage. I have made couple of project in this manner, in addition to previous ones, so I am very happy with this setup and cannot really imagine trying anything else that would work better. Quasar can be also built into a mobile app which is another bonus.

My last full stack passion project I used Axum for the backend/API, Mithril.js with Coffeescript for the frontend, then S3* and Meilisearch for data storage.

FE: Svelte. BE: Go, Postgres. Keeping it fairly simple.

Laravel + Hotwire if working alone or with a small team. Laravel + Inertia if working on a large team or with dedicated backend and frontend teams.

Supabase + Flutter is a stack I can highly recommend if you want to get off the ground fast. Both are extremely intuitive to get started with.

Lately its been Fastify, Postgres and Svelte Kit.

Also tried Remix for a few smaller projects - didnt really fly but was quick to develop.

Fastify has been game changer for me.

picking a stack isn’t enough. you need to codify it and build tooling around it so you can completely forget how it works. picking it up cold after a year should be just as easy as picking it up from yesterday. mine is here[1].

1. https://github.com/nathants/aws-gocljs

With all these modern frameworks and stacks, most of the practical AI UI tools were made with gradio. Interesting contrast.

The last few web apps I've built:

Flask / HTMX / Pico.css / Postgres or Sqlite

Dockerized so that it's easy to spin up.

Edit: Caddy for webserver.

- TypeScript end to end

- infra on AWS via AWS CDK TypeScript

- backend domain plain TypeScript

- frontend plain React, no framework (TSX)

- database RDS Aurora serverless v2 (Postgres)

- monorepo using pnpm

Go, postgres/MySQL,static Vue frontend

Literally anything, thanks to ChatGPT/CoPilot/etc.

Choosing a stack has always been a balance between "what you are currently productive in" and "the best possible tool for the job."

These days, assuming you have a base level of skill and experience, it's like 2-10x easier to get up to speed in a brand new stack thanks to those AI coding buddies

Your current competencies still matter and always will, but today, IMO we're way more free to choose the "best" tool and assume that we can get up to speed quickly.

Putting that aside, I still think Rails is amazing for "most" webby stuff. Would consider Flask if I needed things from the Python ecosystem. Or I guess Phoenix if I needed that massive concurrency. Would pair them with Postgres and/or Redis as needed.

For frontend... Vue? Or maybe just server-side rendering if I could get away with it.

I’d start with rails. It stays out of the way while providing all the core features necessary to grow.

Next.js, material-ui, trpc

Most of what you need to get something functional and not totally ugly, not a lot that you don’t.

HTMX for the front end Go for the backend Postgres for DB Redis for cache

Remember APE. The right medium is always the most

Accessible Powerful cost Effective

relative to your audience and available resources.

I am surprised I haven’t seen angular listed here.

I would pick flutter / istio / booternetes / helm

Elixir with Liveview, or any server side you know well (in my case it’s Java/jsp) with Htmx.

Depends on the app.

Probably Laravel with Livewire and Lit for creating interactive widgets. Postgres for the db.

Htmx+tailwind with rust/leptos serverside. Avoiding JS as much as possible.

Posting here so I can refer back to this...

The ReactJS + Typescript + Rust + LMDB combo just works so well for me.

Do note sqlite3 suffices up to a surprisingly demanding workload.

Today: Expo for web and native, with a FastAPI backend.

Tomorrow: Who knows.

ASP.NET Core MVC + htmlx. Tailwind, ansible, docker

Fronted: React Backend: Golang Database: PostgreSQL

Backend: Go, SQLite

Frontend: Flutter

If Flutter is not possible or suitable than htmx + bulma (or w3c, pico etc..).

Go + htmlx + TiDb or YugabyteDB

SolidStart or Qwik, + postgres

Does anybody still use Perl 5?

i am using svelte and firebase

I just started a project and chose this stack:

- SSR SvelteKit with Hydration (https://github.com/sveltejs/kit)

- PostgreSQL database server

- Postgres.js - PostgreSQL client for Node.js (https://github.com/porsager/postgres)

- Migration powered by graphile-migrate (https://github.com/graphile/migrate)

- PostgreSQL Row-Level Security (https://www.postgresql.org/docs/16/ddl-rowsecurity.html)

- svelte-headlessui (https://github.com/rgossiaux/svelte-headlessui)

- sveltekit-i18n (https://github.com/sveltekit-i18n/lib)

- TailwindCSS (https://tailwindcss.com/)

- Superforms (https://superforms.rocks/)

- sveltekit-flash-message + svelte-french-toast (https://github.com/ciscoheat/sveltekit-flash-message + https://github.com/kbrgl/svelte-french-toast)

Tooling :

- asdf (https://asdf-vm.com/)

- Docker and Docker Compose

- NodeJS

- pnpm

- Jest for unittest

All deployed on a VM at Scaleway (https://www.scaleway.com/en/) with Bash script (https://github.com/stephane-klein/sveltekit-tendaro-webshell...)

After 3 months of development on this stack, I'm very satisfied. My application is fast, light and requires very little code.

Project skeleton example: https://github.com/stephane-klein/sveltekit-tendaro-webshell...

BE - Go

FE - Typescript, React, Tailwind

DB - Postgres

Cache - Memcached

Server/Routing - Envoy

jQuery for frontend, backend in SpringBoot or Quarkus

php, heroku, mysql, redis, cron2go.

- Node

- Either vanilla js or vue.

In a while, s/node/bun

Go on the server is fine as well.

Nodejs

Plain SQL with Postgres

React

Go + HTMX (DB Postgres or Sqlite)

Spring Boot and Thymeleaf. The JS ecosystem has gone to utter shite.

Next.js. I consider it the industry standard