STRONG

The Pragmatic Dev Stack:

SQLite, TypeScript, React, Opinionated Next.js front-end +
Go back-end (API's and CLI's)

In an era of infinite framework churn and architectural bikeshedding, choosing a development stack can be paralyzing.

After building production systems with dozens of technologies, I've converged on a stack that prioritizes one thing above theoretical purity: getting shit done. SQLite for data, TypeScript for type safety, React for UI, Next.js for frontend infrastructure, and Go for backend services.

This isn't the "best" stack—no such thing exists. But it might be the most pragmatically powerful combination for modern development. And it's also one that Agentic coders work great with. I love Python, but without Pydantic its loose-typing can throw Agents right out of their context windows.

SQLite: The Database That Ships With Your App

"But SQLite isn't a real database."

This tired take ignores reality. SQLite powers more applications than MySQL and PostgreSQL combined. It's in your phone, your browser, and your airplane's entertainment system.

For most applications, SQLite is overpowered:
• Handles terabytes of data
• Supports 100,000+ reads/second on commodity hardware
• ACID compliant with better durability than many "enterprise" databases
• Zero configuration, zero administration, zero network latency

An SQLite database is a single file. Version it, copy it, back it up with rsync. Deploy your entire application—code and data—as a single binary.

When you outgrow SQLite, you have real problems—the good kind that come with actual scale, not imagined future scale.

TypeScript: JavaScript That Doesn't Lie

JavaScript's flexibility is both its superpower and its kryptonite. TypeScript adds structure without surrendering the ecosystem.

The value proposition is simple: catch bugs at compile time, not at 3 AM in production. Every refactor becomes safe. Every API change surfaces immediately.

TypeScript's gradual typing means you can adopt it incrementally. Start with any, tighten as you learn the domain. Unlike languages that demand upfront architectural perfection, TypeScript meets you where you are.

The ecosystem is unmatched. Every library has types. Every framework supports it natively. The community consensus is settled: TypeScript won.

React: The UI Standard

Love it or hate it, React became the standard because it solved real problems:
• Component composition that scales from buttons to entire applications
• Declarative rendering that makes UI predictable
• An ecosystem so vast that most problems have pre-built solutions

React's "opinionated" reputation is overblown. It's a rendering library, not a framework. It doesn't care about your routing, state management, or API layer. This minimalism is the point.

The hooks model, despite initial skepticism, proved elegant. useState and useEffect replace classes with functions, reducing boilerplate and cognitive load.

Is React perfect? No. But it's good enough that you can stop thinking about rendering and start thinking about your product.

Next.js: The Frontend Framework That Actually Ships

Raw React requires assembly: routing, SSR, bundling, optimization, API routes. Next.js packages these decisions into a coherent framework.

The magic:
• File-based routing that eliminates configuration
• Server components that blur client/server boundaries intelligently
• Image optimization that just works
• API routes for backend logic without spinning up separate services

Next.js is opinionated in the right ways. It doesn't dictate your state management or component architecture, but it handles infrastructure concerns you shouldn't waste time on.

The App Router (despite growing pains) represents the future: server-first by default, client-side where needed. This inverts the traditional SPA model and dramatically improves performance.

Go: Backend Services Without the Overhead

While TypeScript handles the frontend, Go dominates backend services and CLIs.

Go's value proposition:
• Compiled binaries with zero runtime dependencies
• Goroutines that make concurrency trivial
• Fast compilation that keeps iteration speed high
• Minimal syntax that's learned in hours, mastered in days

Go refuses to be clever. No inheritance hierarchies, no dependency injection frameworks, no magic. Just structs, interfaces, and functions. The language disappears, letting you focus on domain logic.

For CLIs, Go is unmatched. Cross-compile to any platform with a single command. Distribute a 10MB binary that runs instantly. No Python .venv environments, no Node versions, no JVM warmup.

Go's standard library handles HTTP, JSON, templates, and testing without external dependencies. The ecosystem is small because it doesn't need to be large.

Why not TypeScript on the backend? Works fine, but Go will let's you use a much smaller and cheaper server at any scale.

Why This Stack Works

These technologies share a philosophy: pragmatism over purity.

SQLite chooses simplicity over distributed complexity. TypeScript chooses safety over flexibility. React chooses composition over magic. Next.js chooses conventions over configuration. Go chooses clarity over abstraction.

Together, they create a development experience that:
• Starts fast: npx create-next-app and you're building in minutes
• Scales far: SQLite to millions of rows, Next.js to edge deployment, Go to thousands of requests/second
• Deploys simply: Static files and binaries, no orchestration required
• Maintains easily: Strong typing catches regressions, simple codebases prevent technical debt

What This Stack Isn't

This isn't a microservices-first, Kubernetes-native, event-sourced architecture. If you're building distributed systems at Google scale, you need different tools.

But most of us aren't. Most applications serve thousands of users, not millions. Most databases fit on a single server. Most complexity comes from premature architecture, not from actual requirements.

This stack acknowledges that reality. It optimizes for the 90% case: teams building products that need to ship fast, scale reasonably, and maintain sanely.

The Missing Pieces

What about state management? Use Zustand or Context, whichever feels right. What about styling? I prefer Shadcn/UI, but pick your poison. Tailwind, CSS Modules, styled-components, whatever you want. Testing? Vitest for unit tests, Playwright for E2E.

The stack is deliberately incomplete. It establishes foundations—data, types, rendering, infrastructure, backend—without prescribing every detail. This preserves flexibility where it matters.

Conclusion: Get the Tools out of the AI's way

The best development stack is the one you stop thinking about. The one where you spend time solving domain problems instead of debugging build configurations.

SQLite, TypeScript, React, Next.js, and Go form a coherent whole: local-first data, type-safe logic, component-based UI, modern frontend infrastructure, and robust backend services. And I can tell you from experience, Agentic coding platforms love this stack.

Is it perfect? No. Will it work for everyone? No. But it represents a pragmatic equilibrium: powerful enough for real applications, simple enough to actually ship.

Stop debating. Start building.

TL;DR: Frontend in TypeScript, deployed via Next.js, powered by Go services, backed by SQLite. Easy for humans and AI to understand. It just works.