The Simple Stack

This week I built a complete web application in about 12 hours. User authentication, a todo dashboard, CRUD operations, session management, the whole thing. And the entire codebase fits in my head.

How? By aggressively choosing boring technology.

The problem with modern web dev

I've been building web apps for years, and somewhere along the way, the default starting point became absurdly complex. Want to build a simple app? Here's what you "need":

• React (or Vue, or Svelte, or whatever's hot this week)
• TypeScript
• A build tool (Vite, Webpack, Turbopack)
• A CSS solution (Tailwind, CSS modules, styled-components)
• A state management library (Redux, Zustand, Jotai)
• A backend framework (Next.js API routes, Express, Fastify)
• An ORM (Prisma, Drizzle, TypeORM)
• A database (PostgreSQL, MySQL, plus connection pooling)
• Authentication (NextAuth, Clerk, Auth0)

By the time you've set all this up, you've spent three days configuring tools instead of building your actual app. And God help you if you need to update anything six months later.

What if we just... didn't?

I called my experiment "The Simple Stack." The rules were:

1. No build step
2. No npm install
3. Only technology that's been stable for 10+ years
4. The entire app should be runnable with a single command

Here's what I ended up with:

Backend: PHP. Yes, PHP. It's still running most of the internet, it's fast, it's simple, and every hosting provider supports it out of the box. No framework, just vanilla PHP with a simple router I wrote in about 50 lines.

Database: SQLite. One file. No server. No connection management. Just $db = new SQLite3('database.db') and you're done. For 99% of applications, this is more than enough.

Frontend: HTML, CSS, and JavaScript. With jQuery. Yes, jQuery in 2025. It's 85KB, it smooths over browser inconsistencies, and I can write $.ajax() without thinking. Is it trendy? No. Does it work? Absolutely.

Authentication: PHP sessions. Built into the language. No external dependencies.

The actual implementation

The app is a todo manager (original, I know). Users can register, log in, create todos, mark them complete, delete them. Nothing revolutionary, but it has all the pieces of a real app.

// The entire routing system
switch ($_SERVER['REQUEST_URI']) {
    case '/api/todos':
        handleTodos();
        break;
    case '/api/login':
        handleLogin();
        break;
    case '/api/register':
        handleRegister();
        break;
    default:
        serve404();
}

That's it. No Express, no middleware chains, no request/response transformers. Just a switch statement.

The database schema is three tables: users, todos, and sessions. Migrations? I wrote SQL by hand. It took five minutes. If I need to change something, I'll write more SQL. Revolutionary concept.

What I learned

Boring is fast. When you're not wrestling with build tools and configuration, you can focus on actually building the thing. I went from zero to working app in a single day.

Simple is debuggable. When something breaks, I can read the code and understand what's happening. There's no framework magic, no middleware that silently transforms things, no configuration that overrides other configuration.

Old doesn't mean bad. PHP 8 is actually quite nice. It has type hints, attributes, named arguments, all the modern stuff. It's just not fashionable anymore, which means fewer blog posts about it and more people quietly getting work done.

You don't need a framework. For small to medium apps, vanilla code is often clearer than framework code. Yes, you write more boilerplate. But that boilerplate is explicit and obvious. There's no "magic" to learn.

When this doesn't work

I'm not saying everyone should abandon React and write PHP. If you're building a complex SPA with lots of client-side interactivity, React is probably the right choice. If you need real-time features, you'll want WebSockets and something more sophisticated.

But if you're building a simple CRUD app? A landing page? A tool for yourself? Consider whether you actually need the complexity of a modern stack, or whether boring technology would get you to a working product faster.

I've open-sourced the project as a template on GitHub. It's not meant to be a "framework" or anything fancy—just a starting point for people who want to build something simple without spending a week on configuration.

Sometimes the best technology choice is the one you don't have to think about.