The SaaS Starter for Serious Engineers.
Start with the thin starter lane: React 19 + Vite, Fastify, PostgreSQL, email/password auth, workspaces, user settings, generated contracts, and deploy guardrails. When the product needs more, opt into recipes for billing, advanced auth, workers, and deeper admin surfaces.
Built for
- Solo founders and small teams shipping SaaS products
- Devs who want auth, workspaces, settings, and contracts already wired
- Products that need optional billing, workers, webhooks, or advanced auth later
- Teams who want to own the source instead of renting a black-box stack
Not for
- No-code-only teams that cannot own TypeScript code
- Teams committed to fully-managed dependencies everywhere
- Products that need native desktop or mobile clients on day one
- Marketing sites or content-only products without SaaS workflows
Built With
The Infrastructure Gap
Most startups lose months in setup drift. BSLT gives you a default MVP lane now and a scale lane later in the same monorepo.
DIY Approach
Assemble infra from scratch, chase doc drift, and debug webhooks/jobs while product work stalls.
The BSLT Standard
Start from a thin canonical starter in the monorepo. Auth, workspaces, user settings, contracts, and deploy guardrails are wired; deeper platform systems stay opt-in.
One Monorepo.
Two Product Lanes.
Lane A is the default: ship MVP fast with one workflow, one env template, and one deploy path. Lane B is opt-in: add deeper providers, infra modules, and platform controls when scale actually demands it.
The SaaS Trap
"The Wrapper"Fast to start, but costs and constraints can grow. Consider the tradeoffs as you scale.
- Tied to specific vendors
- Unpredictable pricing spikes
- Data exists in black boxes
- Harder to migrate as you scale
The DIY Slog
"Refactoring Hell"You ship quickly, then pay the rewrite tax because the starter was never designed to scale.
- Fast start, slow rewrite cycle
- Feature work blocked by infra debt
- Docs and scripts drift apart
- Reliability work postponed until production
The BSLT Standard
MVP Fast + Scale LaterA clone-and-own foundation with thin starter defaults, generated API clients, focused tests, and provider boundaries that are explicit instead of hidden.
- Clear Platform vs App split
- Canonical starter app as source of truth
- Contract, client, schema, and route coverage audits
- Docker, Cloudflare, DigitalOcean, and GCP deploy paths
Starter Profile.
Recipes When Needed.
The current starter profile enables core, db, and system capabilities by default. Billing, advanced auth, workers, webhooks, and deeper admin tooling stay available as opt-in recipes and reference surfaces.
Starter Profile
The active profile keeps the default app focused on core, db, and system capabilities, with optional modules kept behind recipe boundaries.
Generated API Clients
Server route contracts generate browser clients and React hooks, then audits check that contracts, clients, schemas, and routes stay aligned.
schema
generated
Fastify
Contracts, clients, schemas, and routes are audited together.
Web + API Starter
The default product surface is a Vite React web app backed by a Fastify API, PostgreSQL repositories, and local dev services.
Starter Auth
Email/password registration, verification, password reset, sessions, account settings, and workspace membership ship in the default app.
Billing Recipe
Enable billing when the product needs it. The recipe adds pricing, checkout, billing settings, provider wiring, and admin linkage.
Workers Recipe
Keep the starter small, then add background worker capability for retries, scheduled work, and long-running product jobs when needed.
Minimal Admin.
Expanded by Recipe.
The starter keeps admin small: health, readiness, and user lookup. Enable the advanced admin recipe when you need tenants, jobs, webhooks, audit views, feature flags, or legal tooling.
Health and Guardrails
Expose the operational basics first: health checks, readiness checks, auth guardrails, and rate-limit posture.
admin health
Advanced Admin Recipe
Add jobs, webhooks, audit logs, legal records, feature flags, route diagnostics, and tenant operations when your product needs them.
pnpm enable advanced-admin
User Lookup
Start with a small authenticated admin surface for user lookup and support checks instead of a sprawling console.
admin users
Built for the
Growing Team.
BSLT keeps frontend and backend work connected through checked contracts, generated clients, route registration, and audit scripts. The repo is structured so teams can add product code without guessing where boundaries live.
Parallel Velocity
Stop saying "Is the API ready yet?" Define request and response contracts first, generate the client, then let the server route and UI move together with drift checks guarding the boundary. Fewer blocking dependencies.
Automated Governance
You can't review every boundary by hand. BSLT's audit scripts check route contract coverage, public assets, docs links, imports, formatting, lint, types, tests, and build health.
useVirtualScroll()
@param itemHeight - Fixed height of row
@returns { scrollTop, visibleItems }
Instant Onboarding
The repo documents the starter path, profile boundaries, deploy recipes, environment setup, and verification commands. New contributors can follow docs instead of reconstructing the system from scattered code.
Full Source Access.
No Hidden Dependencies.
We use focused internal libraries instead of heavy frameworks. You can read, modify, and extend every line of code.
Generated Route Contracts
Request and response contracts generate API clients and React hooks. The route-contract audit verifies that server routes, contracts, schemas, and clients stay in sync.
Postgres-First Data
The default app uses PostgreSQL with custom SQL repositories. Production compose adds PgBouncer and Redis where the runtime needs cache, rate limiting, or clustered guardrails.
Starter Auth
Email/password auth, verification, password reset, sessions, user settings, and workspace membership are part of the starter lane. Advanced auth stays opt-in.
Headless UI System
Shared UI primitives, CSS variables, preview routes, and tokenized themes keep the app cohesive without adding a heavyweight design-system service.
Engineering Standards,
Not Shortcuts.
Every line reviewed. Every edge case tested. Every type enforced.
Strict Type Safety
TypeScript across web, server, shared packages, generated clients, and repo tooling.
Checked Schemas
Custom schema objects define request and response boundaries, then audits verify route coverage.
CI Guardrails
Formatting, lint, type checks, template audits, docs-link checks, tests, and builds are part of the baseline.
Focused Test Health
Vitest, Playwright, integration tests, and route-contract audits protect the starter's runtime paths.
The Starter Spec Sheet
The default lane stays small; recipes add platform depth only when needed.
- Web App: React 19 + Vite with authenticated dashboard, settings, and workspace UI.
- API: Fastify server with typed request/response contracts and route registration.
- Database: PostgreSQL with custom SQL repositories and migration tooling.
- Starter Auth: Email/password, verification, password reset, sessions, and account settings.
- Workspaces: Creation, switching, member list, invitations, and basic roles.
- Admin Basics: Health, readiness, and user lookup for admin users.
- Generated Clients: API clients and React hooks generated from checked contracts.
- Security Guardrails: Headers, CSP, CSRF, input validation, rate limiting, and audit logging.
- Local Storage: Avatar/file support with local serving for development demos.
- Search: SQL search provider by default; alternate providers are explicit adapter work.
- Deploy: Docker compose, Caddy, PgBouncer, Redis, and provider guides.
- Recipes: Billing, advanced auth, advanced admin, and workers are opt-in.
- Profiles: Starter, full, and custom profiles keep feature boundaries explicit.
- Verification: Tests, type checks, lint, audits, docs-link checks, and production builds.
Zero-Config Component Catalog
The web app includes a UI library preview route so components can be reviewed inside the same browser environment where the product runs.
Synced Project Config
Stop fighting tsconfig.json paths.
Sync scripts keep aliases, imports, package boundaries, generated clients, and profile metadata aligned as the repo changes.
The Repository Pattern
We don't leak SQL queries into your API routes. Data access lives behind custom SQL repositories in the server/database packages, keeping route handlers focused on HTTP behavior.
Architecture
Read by Agents.
The repository documents its starter profile, deploy paths, contract audits, recipes, and operational guardrails so agents can navigate the codebase with concrete context.
Your coding agent can read the same docs and verification scripts a human contributor would use.
Free & Open Source
Clone the starter, run the verification baseline, and make the code your own.
The default starter path is intentionally thin. Enable recipes when billing, advanced auth, background workers, or deeper admin operations become real product requirements.
Questions?
What tech stack does BSLT use?
TypeScript everywhere: React + Vite for the frontend, Fastify for the API, PostgreSQL with custom SQL repositories, generated API clients, Docker for local development, and Turborepo + pnpm workspaces for the monorepo.
What ships in the default starter?
The starter includes a Vite React app, Fastify API, PostgreSQL, email/password auth, user settings, workspaces, basic admin health/user lookup, local dev services, generated contracts/clients, tests, and deploy guardrails.
How do optional modules work?
Optional systems live as recipes and reference surfaces. Use commands like
pnpm recipes:list and pnpm enable billing to opt into
billing, advanced auth, advanced admin, or workers when the product needs them.
How do I rename and verify a new app?
Use the documented starter flow: bootstrap local services, rename the project with
pnpm starter:rename, enable only the needed features, then run
pnpm starter:verify, tests, type checks, lint, audits, and build.