Ask HN: What is the most pleasant, uncomplicated full stack to start with? | Hacker News Reader

Ask HN: What is the most pleasant, uncomplicated full stack to start with?

42 pointsweakfish74 comments

Hey HN,

I'm a backend/systems programmer by trade who has always wanted to build a full stack app, but gets frustrated / overwhelmed by 'modern' web dev. I’m incredibly wary of overcomplicating and don’t want to throw in the entire kitchen, if YAGNI. I want to build a somewhat complicated UI (think Notion level) and not completely bend over backwards making the front-end work through 10000 layers of abstraction.

Right now, I'm looking at Svelte(kit) and a Go (stdlib) or Rust (Axum) backend. I know Rust is a bit of a meme, but I find it very pleasant to write vs. Go in a lot of respects.

Is there something else out there that is worth trying? I have thought about trying Elm, but it seems to be niche / not future-proof.

Thanks.

View on HN

IMO Ruby on Rails remains the "uncomplicated" standard for building full-stack apps. Especially notion-like CRUD apps. It's fast, uncomplicated (convention over configuration), and enjoyable to write apps in once you understand the basics. I still think Ruby is an incredibly fun language to write in.

You mention that you get frustrated by modern web dev - I assume you mean the insane world of javascript frameworks. You can build entire rails apps without ever really worrying about JS these days.[^1] Hotwired lets you build fairly complex UIs and add a ton of interactivity without JS. But if you ever want to do more with JS on the frontend it's very easy to adapt rails to just about any frontend JS framework, including React and Svelte.

That said, there's comparable full-stack frameworks in many languages, and if you just want to hit the ground running you might as well use what you know. Ruby - Rails. Java - Spring. Python - Django. PHP - Laravel. You can use whatever frontend you want with any of those frameworks.

Stick with Postgres or Mysql/Maria for the database. They're tried-and-true and scale to whatever size you will ever need.

[^1]: https://hotwired.dev/

Ruby doesn't have the typing required to be a pleasant modern language

Types aren't everything to everyone.

I haven't used it personally but if you're looking for type-checked Ruby, look into Sorbet from the folks at Stripe.

- https://stripe.com/blog/sorbet-stripes-type-checker-for-ruby

- https://sorbet.org/

Deploying though is very complicated.

You might want to check out fly.io

https://fly.io/docs/rails/

I started my career in RoR and regret doing so - I really had no idea what was going on, found a gem for everything, and understood very little about performance tuning other than some nuances about ActiveRecord. I wish I started with React+Python/Django, would be incredibly marketable.

I see way more job opportunities in Rails than Django, but I guess it depends what kinds of circles you run in. I don't care much for frontend development so I have stayed away from React, but yeah that's certainly the skill to have for frontend work these days.

React+Rails makes you insanely marketable these days. There's SO MANY companies with large rails apps out there that aren't going anywhere.

That's interesting to hear, I didn't know Rails was a growing community. I haven't gone to public tech talks in sf in a while (3 years before covid), so wouldn't have as updated pulse on the market. Fwiw, the best advice i got in my short stint as a ruby developer was to check out "Destroy All Software" - https://www.destroyallsoftware.com/screencasts/catalog - the strongest engineer I knew loved it, hope it helps someone out

I don't know if it's a growing community, but whatever it's doing now, it's starting from a fairly large base compared to many others.

I'm not a fan SPAs for everything but something like notion has to be a SPA. I don't see how prioritizing backend frameworks as the most important part helps here.

OP asked for a full stack solution so that's what I gave him. There's no reason you can't use rails and something like react on the frontend for building a SPA Notion clone. Rails may seem like overkill for an API-only mode but I think it's perfectly useable and pleasant to develop that way.

Just did a quick google search and this is the first result I found: https://github.com/brandonfang/lilnotion

If your goal is to build a product for your own startup business, the best stack is Google Forms + Google Sheets. Then getting on the phone and selling.

If your goal is to learn the marketable skill of building web apps in 2023, you can't go wrong with Typescript on the front and back end with NextJs (aka React, aka one of the most in-demand technologies employment-wise in the industry).

If your goal is to just have some fun on then Svelte + Rust ain't a bad idea.

My stack nowadays is MySQL server + MySQL Workbench.

I have a few hobby projects which use Google Sheets as a backend. It's great.

Google Forms is a great frontend for Sheets if you just need a way to collect data.

> back end with NextJs

Can you actually use NextJS as a back end? It's been a few years since I last worked with it. I recall it ran a server we had to deploy, but that server only did some server side rendering of the frontend.

Yes, it has a straightforward concept of /api/* endpoints that can be leveraged for any type of backend.

Yes (https://nextjs.org/docs/api-routes/introduction); you can even have libraries and frameworks that use API routes as a target.

Sure. If you deploy on Vercel you can have it serverless. If you are careful with bundles and providers you can even use only one nextjs project for the website, docs, auth, webapp, public api and whatnot.

Python's Flask and Dataset libraries + Axios and Vue on the frontend (doesn't even have to be the full build/component/single page application setup, just include it as script and populate the app values with Flasks render_template() parameters)

https://flask.palletsprojects.com/en/2.2.x/quickstart/#a-min...

https://dataset.readthedocs.io/

https://github.com/axios/axios

https://vuejs.org/guide/introduction.html

https://vuejs.org/guide/extras/ways-of-using-vue.html

I've created a boilerplate here:

https://github.com/void4/lazyweb

Python doesn't have the typing required to be a pleasant modern language

What are the main pleasantries missing from Python's type-hinting?

I have a Django backend that says otherwise

Not recommending something specific, but I would personally pick up front complexity over long term complexity. Avoid easy button setups and stacks designed to "make you productive in minutes" and spend the time learning how to make a stack that you comprehend and have customized to your needs.

Phoenix liveview gives you almost-spa out of the box with relatively little fuss. Of course if you want dead routes you can have those too. You get the safety of a pragmatic fp with escape hatches for stateful stuff (like db access). The designers came from RoR so it really takes care of a lot of easy to screw up things, but they also removed a lot of the super hard to understand RoR magic.

It's future-proof too, if you want to bolt on say machine learning, or data processing pipelines later, that's becoming a real thing in the ecosystem.

I was watching a video on someone writing an Ethereum indexing system in go. One frame had their super complicated concurrent processing system, and my eyes bugged out. Also they claimed there was a concurrency bug. I wound up writing an equivalent in elixir in about a week, no concurrency bugs.

Another point, phoenix app ages nicely. Got product that was online from 1.1 (2016) days with no maintenance, upgrading it to latest took only two days or so, mostly spent on 3rd party deps.

Django. Makes it easy to build a classic server rendered web app with authentication, forms derived from models etc. Also comes with an automatically generated admin backed. Always my first choice when I want to get something solid out fast.

If the server rendered experience is not enough, you can add some HTMX.org or Svelte. You're also free to go full blown SPA later on and use Django more or less as backed - there are great REST add-ons.

Rails is still the king of productivity. The no-JS-framework-needed approach to front-end that it is championing in version 7 is refreshingly simple to work with

This is the wrong question because everyone is going to answer a different question, namely "What do you like developing in?" It's massively subjective and depends entirely on what your experience is and what you're trying to build.

Build with what you know to start with. Find a way to frontend that you don't hate. Focus on making your data and algorithms portable. Change your opinion and tech stack when (if!) you need to.

IMO, all stacks have their complications.

I generally liked working with NodeJS, and plain JavaScript both on the server and browser side. It shines for applications where things are kept extremely simple.

If things are going to get a little complicated, swapping in Typescript will bring in the compiler to check things for you. This will be useful if your codebase gets large enough to refactor, and benefit from a statically checked compiler.

Remember that plain JavaScript in the browser is a thing, and if your needs are simple, you can do a lot with it.

Also: I really like Blazor and C#. It's a completely different stack, and much more complicated. But it's much more powerful, and the straightforward, templated HTML via razor is a real joy to work with.

Edit: One nice advantage of server-side Blazor is that you don't need to write an API to do AJAX. (IE, you can mix database queries in your UI code.) This "keep it simple" has it's place in some situations. (Of course, you can do in-browser Blazor with a proper API and separate layers if needed.)

Javascript on the backend. Javascript on the frontend.

If you hate javascript then php and laravel on the backend, javascript on the frontend.

My goto as well, mern (MySQL/Maria)

If you hate JavaScript you still need it on the frontend so you might as well use it everywhere.

true

If you want to build a business: Just use Django (or Rails). Avoid all the other more complicated things.

If you care about performance and being productive: Go

If you want to play with new tech: Rust

Django if you already know python. Rails if you are getting started or already know js

Flask or CherryPy are easier and lighter for python than Django.

FastAPI is on the rise for python and is also something to consider if scaling is a concern.

Flask and CherryPy aren’t the same thing. Of course they’re easier and lighter: they offer less.

You can build your entire startup with JUST Django or JUST Rails. That’s frontend and backend. Flask/CherryPy/Express just give you the backend and leave you writing JavaScript for your frontend.

It really depends on what you want to build. For typical web applications (e.g. SaaS) this stack is almost perfect:

Next.js for client- and server-side development (alternatively look at Remix). It's a big advantage to use Typescript on both sides instead of mixing programming languages like JS + Rust or GO (or PHP, Python, Ruby ...).

In case you need a database (MySQL or Postgres) then PrismaORM is your best friend. Amazingly good ORM which does all the heavy-lifting for you.

For hosting without database Vercel is the obvious solution. In case you need a database, then look at a good PaaS like Render.com (or if you are in EU then scalingo.com). In any case don't waste time with building infrastructure.

In case you want to see a full application, check out our open-source Kickstarter.

Repo: https://github.com/roqtech/roq-kickstarter-nextjs Demo: https://roq-kickstarter-nextjs.vercel.app/

Repo (with Prisma): https://github.com/roqtech/roq-kickstarter-nextjs-prisma-mar...

if anyone is interested in a PaaS like experience with the surface area of AWS or GCP we're building https://docs.withcoherence.com/ for full stack web apps

LAMP/LEMP

Linux, Apache/Nginx, MySQL, PHP

There's something to be said for a set of technologies you can continue using for a couple decades.

I don't use MySQL anymore but otherwise this is my favorite stack. Nowadays, I use sqlite, flat json files, or google sheets.

People have continued using Fortran and cobol for decades. Doesn't mean they are good or pleasant.

Try refactoring 20 year old php then tell me it is pleasant. If you can't, it shouldn't be recommended to OP

Fortran will outlive every single JS framework mentioned on this page, and then some. There's definitely good and pleasant in knowing that your code will run for many years to come, if your project has such a timespan. Therefore, PHP is absolutely a valid recommendation.

Ding. Ding. Ding. Basically my response :).

Fortran surviving so long is due to lock in, not merits. That is a bad thing, not a good one.

Not sure why you think 20 year old PHP code would be difficult to refactor. It's extremely backwards compatible and things don't change much at all.

I have a couple large projects written in PHP from 10-20 years ago that I'm sure I could refactor or make changes to easily.

https://github.com/photo/frontend

https://github.com/jmathai/photos

Also, see this: https://github.com/rectorphp/rector

Instant Upgrades and Automated Refactoring of any PHP 5.3+ code

Ruby on rails is still good and getting better. It has almost every answer/guide possible already on the internet. Otherwise if you prefer better typing, I'm poking https://github.com/luckyframework/lucky from time to time... It looks interesting, but doesn't have a large user base yet.

For the front-end, I found Vuejs quite nice to add exactly where it's needed. Otherwise I can leave 99% of the site a plain html template.

I've been researching JS frameworks recently for a personal project. Like you, my experience is with backend, old-school Django-style HTML multi-page apps, with some interactivity in specific parts of a page.

Things I thought that were cool and were genuinely exciting:

- https://htmx.org - this is my favorite option. It's primarily meant to replace AJAX requests that dynamically update the DOM (which is already a big win IMO). For more complex UI interactions, you'll still need JS or Hyperscript.

- https://hyperscript.org - wasn't immediately sold on this one like with HTMX. It's built by the same people as HTMX though. My favorite thing about it is it makes async transparent (no callback hell)

- Svelte, SolidJS - lumping these together since they look about the same from my point of view. Looks very easy for someone like me to build complex dynamic UIs. But still feels a bit too heavy for my tastes (Default setup is for full-blown SPAs)

- Go - awesome standard library. Lots of tutorials and easy to find answers. I needed to adjust to the lack "one framework to rule them all".

- Clojure/ClojureScript - Like Go, there's no "the one framework". Being able to use the same language for backend/frontend, including code sharing, is pretty sweet.

In the end, I chose Clojure + ClojureScript. I aws already familiar with Clojure, and with some wrangling/trial-error, I managed to get a ClojureScript setup that lets me write small interactive components that I can embed into specific parts of plain old .html files.

I intend to use HTMX for AJAX stuff, and ClojureScript for more complex interactivity. Haven't gotten very far yet, but that's the plan.

Phoenix framework and Elixir get a lot of love here if you are willing to dive into functional programming languages.

If you're trying things out: Jekyll + Liquid templates rendering YAML are wonderful. Hosted natively on GitHub Pages.

It produces a static site & lets you focus entirely on the UI side, without linking the frontend to a 'real' backend/database. Good enough for a blog/similar style of site.

You may prefer Svelte, but Vue is fairly simple with its single file with template, class, css all-in-one. Making components, using them, and getting events is super simple.

For backend F# with simple Giraffe lib/framework? worked pretty nicely. You won't get the full ecosystem of crates though and mixing C# libs might not be the most natural. I want concurrency/parallelism but have no patience/need for a borrow checker. Rust is a nice language though and wish I worked on something where it mattered, liked it more than I'd expected.

Python/Django. I keep coming back to it for my projects.

Do you pair it with any JS for interactivity?

PHP with Laravel + Livewire. It's easy to pick up and you don't really need to know anything else than PHP, HTML and Laravel (which is really easy to find a ton of articles for just about any task).

It ain't sexy but it gets the job done so smoothly, and modern PHP is certainly better than it used to be, although still a 3 headed Perl dragon with the consistency of a toddler high on sugar.

the microsoft stack, which there are an unsurprising number of people on.

edit: I read the title as 'unpleasant', lol. I do not endorse this comment.

I have built Web front-ends (React or Svelte) with Go-backend. Embed in a web-view to make it a native desktop app, or get funky and give it native chrome/menus etc. [Wails](https://github.com/wailsapp/wails) is a good candidate to start if you want to cut on boiler plate.

Wasm to the rescue - https://go-app.dev/, https://yew.rs/.

I enjoy it as much as Vue 1.0 before we had bundlers, transpilers, builders and what not.

Ruby on Rails

^this

Even if we are attracted by new libraries (Svelte) or think of going with the most popular choice (React), Rails is still one of (if not THE) most comfortable fullstack frameworks for building web apps.

Typescript. I love how flexible the type system is and the ability of share logic in frontend and backend.

For backend dotnet core is also nice. Fast and batteries included. I would avoid their Entity framework though. I still prefer TS.

I just started studying Springboot and React for the same purpose,LOL.

Sveltekit + go FTW. I prerender my frontend so it's fast and cheap to host with go deployed on cloudrun.

https://remix.run

Do the whole thing in typescript.

Have the power of reusable components using React.

Serve zero JS if you want to.

I think it makes sense for everything Javascript right now, pick a framework like Nest.js and a good ORM like MikroORM and get going.

https://www.meteor.com/ -- I'm still a fan.

ReactJS + ExpressJS + PostgreSQL is my go to.

But I’m also looking at:

React Native + Supabase

Elixir, Phoenix and Liveview

Two alternative options you might consider are redwoodjs and blazor

Python/flask with server side rendering.

SwiftUI and Ruby on Rails

Django

swiftui + cloudkit

Reply on news.ycombinator.com