Two ways in: use it to get grounded answers from your own documents today — no setup — or own the AWS codebase behind it: auth, an IAM-authed database, deploys, backups, and a working AI module, so you can start on your actual product instead of a blank repo.
Free until you have real users. Serverless cost tracks usage, not time — measured spend before revenue is under $2/month.
Pick the one that fits you. Both start with a quick access request below.
For business owners and teams. Upload your documents and get accurate, grounded answers in seconds — no code, no setup, no AI expertise required.
For developers. Get the full source — auth, IAM-authed database, CI/CD, observability, and a working AI (Bedrock RAG) module. It runs in your GitHub and your AWS account — you own it end to end, and we help you through setup.
Grounded answers from your own documents, running on AWS Bedrock — included and working from the first deploy. No API keys, no model plumbing, no ML team. It answers from your content, and tells you plainly when the answer isn't there.
Ask in plain English; answers come straight from your content — accurate and specific, never invented.
When it doesn't know, it says “I don't have that yet.” No confident hallucinations, no guessing.
Your documents stay in your account, isolated per user and IAM-authed — nothing shared, nothing trained on.
Titan embeddings + Claude, wired and working out of the box — no API keys, no model plumbing, no ML team.
The parts most side projects skip — until they bite you in production.
Auth, IAM-authed DB, secrets isolation, rate limiting, OWASP error handling.
Five test layers — including Playwright UI end-to-end tests — and a staging gate stand between you and production.
GitHub Actions check every push and gate every deploy — nothing reaches prod un-tested.
CloudWatch alarms for errors, throttles, latency and 5XX, plus an AWS Budgets alarm.
Serverless cost tracks usage — under $2/month before revenue.
The human operating model that makes AI-built software actually hold up — ownership over rules, forcing functions, a compounding pitfall library. The part you can't clone →
Everything below is built and working — not a to-do list.
The AI module, wiredGrounded document Q&A on AWS Bedrock — Titan embeddings + Claude, an honesty gate, and per-user isolation. Included and working, not a stub to build later.
Agentic-readyA Bedrock tool-use loop and tool registry are wired in and tested — add your own tools. The path to approved, human-in-the-loop actions is documented, not hand-waved.
The stackVanilla JS SPA → API Gateway → Lambda (Node 24, Express) → Aurora DSQL (scales to zero) → SES — all IAM-authed, no long-lived DB password.
Auth done rightbcrypt, JWT, email verification, admin approval, brute-force lockout, enumeration prevention, password strength.
The full delivery pipelineSetup wizard, schema migrations, staging gate, smoke tests, frontend deploy with cache invalidation, a doctor health check.
CI/CD + observabilityGitHub Actions for test-on-push and gated deploys, plus one-command CloudWatch + budget alarms.
Disaster recoveryVersioned S3 data backups with a round-trip-tested restore, one-command backup/restore scripts, deploy rollback, and a DR runbook — because DSQL has no native point-in-time restore.
The ingredient guidesTesting, security, scalability, disaster recovery, observability and cost docs — so you understand the system, not just run it.
The "now what?" bridgeA guide that walks you from a working skeleton to your first real feature, in the order that never burns you.
Five steps. The heavy lifting is a single command; the rest is a clone and a deploy.
No prior cloud experience needed — and if your team already has AWS chops, you'll move through this even faster. The free tier plus scale-to-zero DSQL keeps spend under $2/month until you have real users.
AWS CLI, GitHub CLI, Node 24, and psql — each a one-line install, all free.
One command — node provision.mjs — creates the IAM role, DSQL database, secrets, Lambda, API Gateway, and S3 bucket. Idempotent and resumable if it stops.
bash deploy.sh runs tests → staging → smoke tests → prod. bash deploy-frontend.sh ships the site and invalidates the cache.
The FIRST_FEATURE guide walks you from a working skeleton to your first real feature — in the order that never burns you.
Prerequisites: an AWS account, plus AWS CLI, GitHub CLI, Node 24, and psql — nothing else, nothing paid.
A free boilerplate is a snapshot in time. This one is maintained, and it keeps improving as real projects hit real problems.
The real cost of building on AWS isn't the first deploy — it's the small, expensive mistakes between deploy and a stable product: the DSQL constraint that isn't standard Postgres, the API Gateway timeout at 29 seconds, the config call that silently wipes your env vars, the CloudFront cache that serves a stale frontend for hours. Each one is already a documented pitfall here, with the cost and the fix.
And it's a two-way street: when you hit a sharp edge or find a better pattern, you can send it back — improvements roll into the starter, so everyone building on it (you included, on your next project) benefits. You're not buying a static folder of files; you're building on something that gets better over time.
Generating code is the easy part now. What makes AI-built software actually trustworthy is a partnership: a human owns the outcome and the direction; the AI owns tireless craft, recall, and breadth. Neither produces this alone — and the discipline that joins them is the part you can't copy out of a repo.
AI optimizes for “done” and has no stake in whether it actually works — only a human can own that. The kit is built ownership-first, with the checklists and gates as the expression of that ownership, never a substitute for it.
The things that matter are gates, not notes: a staging smoke test that won't let a broken endpoint deploy, an end-of-session check that won't let project state rot. Quality doesn't depend on anyone remembering.
Every mistake becomes a dated, cost-tagged pitfall the next build can't repeat. The system gets smarter every session — you never pay twice for a lesson already learned.
Not marketing. Things that actually happened building this, where the partnership caught what neither side would have alone.
The agent concluded a database migration was impossible and wrote it down as fact. A human said, “check the docs again.” It wasn't impossible — and that one exchange unblocked three-plus weeks of work that had been routed around by hand.
A provisioning script had looked finished for six weeks and passed every check. Insisting on a single real end-to-end run surfaced four bugs — each of which would have blocked every new user on their very first try.
A feature shipped without a test. Instead of explaining it away, we owned it, fixed it, and captured the pitfall — so the gate now catches that class of mistake automatically. No blame, no essay, no next time.
AI accelerates execution. It doesn't transfer responsibility. The human element is what closes that gap — and it's built into how this is made, not left to chance. We're better together, and this platform depends on it.
Most builders abandon a SaaS attempt at one of five predictable cliffs.
| The cliff | The fix |
|---|---|
| Setup too hard | Dependency-free setup wizard + SETUP guide + a doctor health check |
| First deploy fails | doctor validates the whole environment before you deploy; staging gate catches prod-path bugs |
| Cost shock | Sourced cost numbers + "free until real users" + budget-alarm setup |
| "Now what?" | An end-to-end guided bridge to your first feature |
| Drift | Schema contract, smoke tests, a pitfall catalog, and a live state file keep the project honest |
Honesty is part of the product. For a commercial SaaS you'll also need things this skeleton doesn't ship today — flagged plainly, and on the upgrade roadmap:
Access is granted by invitation. Request access below and verify your email — you'll be approved by the owner before you can sign in.