Building a Lightweight SaaS Architecture With Bun and SQLite

When building a modern web application, it's tempting to start with a large infrastructure stack. Databases, caches, queues, containers, and microservices can all be useful—but adding them before they're necessary can make development and maintenance harder.

While building CampusTPO, we took a more lightweight approach.

Why Keep the Stack Simple?

CampusTPO is built around Bun and SQLite, with a modular application structure.

SQLite provides a relational database without requiring a separate database server. Combined with WAL mode, it provides a practical foundation while keeping deployment relatively simple.

The important lesson isn't that SQLite is always the best choice.

It's that infrastructure should match the application's actual requirements.

Authentication and Security

Authentication is treated as part of the application's foundation.

The application includes:

• Email/password authentication
• Email verification
• Google sign-in
• Password recovery
• Session management
• Account management

Security is also built into the architecture through:

• Role-based access control
• CSRF protection
• Content Security Policy
• Rate limiting
• Password hashing
• Audit trails

A Modular Architecture

The codebase separates responsibilities into clear layers:

Routes
   ↓
Services
   ↓
Repositories
   ↓
SQLite

This keeps request handling, business logic, and database operations separated without requiring a distributed microservices architecture.

Don't Build for Problems You Don't Have

A queue can be useful when background processing becomes necessary.

A cache can be useful when there is an actual caching problem.

A distributed database can be useful when the workload requires one.

But introducing these components too early creates additional configuration, deployment, monitoring, and maintenance requirements.

Instead, the architecture can evolve as real requirements emerge.

The Bigger Lesson

Building CampusTPO has reinforced a simple principle:

Start with the smallest architecture that solves the current problem well.

Keep the boundaries clean, measure real bottlenecks, and introduce additional infrastructure when there is a genuine reason for it.

Good architecture isn't about using the most technologies.

It's about understanding why each component exists.

Tags: #webdev #saas #architecture #bun #sqlite