The Lean Stack: Why We Went Back to HTML, CSS, and Fundamentals
Having spent over 15 years as a CTO and software engineer building web applications (from early jQuery setups to complex single-page applications), I watched the industry bury basic web principles under fragile build pipelines and heavy hydration overhead. Over the past year, my production projects (including this website) run on a lean stack: pure HTML, CSS, Vanilla JS, and focused tools like Alpine.js, htmx, and Bun.
No React, no Next.js, and no unnecessary bundler churn.
Development velocity has increased noticeably compared to building with heavy modern framework pipelines.
1. The Frontend: jQuery and Bootstrap, Evolved
Fifteen years ago, web development was straightforward: jQuery for interactivity, Bootstrap for layout, a single HTML file, and refreshing the browser. That simplicity never stopped working; it was gradually buried under complex build configs and hydration errors.
The lean stack represents the evolution of that model:
- Alpine.js: Reactive behavior declared directly in HTML markup, providing component-like state without heavy client runtimes.
- htmx: The server sends HTML fragments and the DOM updates directly, achieving fast dynamic interfaces without converting the whole site into a heavy JavaScript client.
- Bulma CSS: Clean, semantic CSS framework that handles responsive layouts without bundled JavaScript.
Together they weigh a few dozen kilobytes. The browser does what it was optimized to do: parse and render semantic HTML. There is no compilation step, no client hydration delay, and when an error occurs, it appears directly in the written file.
2. The Backend: Bun, Hono, and TypeScript
On the server, we pair this with Bun and Hono in TypeScript. A single binary provides instant startup, built-in SQLite support, and a lightweight router. A full production website (server-rendered pages, analytics, and admin dashboard) fits into a compact codebase that a single engineer can understand completely.
In the era of the one-person dev team, the limiting factor is how much of the system one engineer (and their AI assistants) can hold in context. A lean stack minimizes surface area so development stays fast.
3. Same Philosophy Down to the Metal
This fundamentals-first mindset extends to hardware. For ESP32 sensor nodes and single-board computers on factory floors, we use Rust: no garbage collector, no heavy runtime, and direct hardware control. The strict compiler provides immediate validation that works effectively with AI code generation.
For more details on that setup, see Rust on ESP32 and Single-Board Computers: Our Embedded Stack.
4. Infrastructure and Local Governance
The other side of the lean stack is where it runs: on self-hosted hardware.
A decade of default cloud adoption introduced significant data governance risks. Data sits in external regions, uptime depends on third-party status pages, and AI features route customer data through remote APIs under changing terms.
Self-hosting is a practical requirement for local AI. Running models on internal data (contracts, financials, operations) requires infrastructure you directly govern. As argued in Technology is Real Power, data ownership and infrastructure control determine real operational independence.
A Bun/Hono service running on a modest self-hosted box behind a secure tunnel easily handles the traffic requirements of most small to mid-sized businesses.
5. Engineering Efficiency
Cloud practices often encourage solving performance bottlenecks by scaling hardware rather than fixing software inefficiency.
Many workloads generating heavy cloud bills could run comfortably on a single machine with basic optimization: resolving N+1 database queries, replacing oversized JavaScript bundles with static HTML, and consolidating microservice serialization overhead.
Self-hosting makes resource constraints concrete. Memory, CPU, and disk usage are immediately visible, encouraging proper indexing and server-side caching. Bun serving rendered pages with SQLite on local NVMe storage handles high throughput with zero network round-trip delay.
This efficiency becomes critical for AI workloads, where GPU compute and tokens represent significant operational costs.
6. Mindset Shift for Engineering Leadership
The main challenge in adopting simpler architectures is managerial rather than technical.
Industry norms often equate professional engineering with complex multi-layer frameworks, large build farms, and specialized frontend sub-teams.
AI coding tools shift these incentives. AI assistants operate most reliably on clean targets: semantic HTML, standard CSS, and compact backend functions. Reducing framework abstraction layers lowers context consumption and improves generation accuracy.
7. Mobile Distribution via PWAs
Applying web fundamentals to mobile often removes the need for native app store distribution.
A Progressive Web App (PWA) built on this stack covers typical business needs (dashboards, ordering, scheduling, and field operations) with offline support and push notifications from a single unified codebase.
This avoids 30% platform fees, lengthy review cycles, and arbitrary store policies for standard commercial applications.
8. Conclusion
Using Alpine, htmx, Bun, Rust, and local models is a practical, modern approach to software development. It returns control over markup, servers, data, and distribution to builders.