Jishu Labs is a suite of eight AI-augmented developer tools — code review, voice notes, schema design, learning paths, project estimation, spec generation, and more — sharing one backend, one design system, one authentication layer, and one LLM integration surface.
Built and shipped solo as a personal platform I dogfood every day: a codebase where new AI tools take days rather than weeks because the foundation is already solved.
The challenge
Building eight independent tools solo is a recipe for drowning in undifferentiated work.
Every tool needs auth, a database, a UI system, billing hooks, AI integration, deployments, and observability. Done eight times, that's eight months before any of them ship anything interesting. The real challenge was making each tool feel independent to users while sharing everything that should be shared under the hood.
Eight toolsbuilt and shipped solo
Shared foundationsauth, data, UI and AI
Independent feelfor every user
The solution
One shared backbone, thin apps on top.
Invested in one shared backbone — Supabase for auth and Postgres, a TypeScript component library for UI, design tokens for theming, and a set of reusable LLM integration primitives (streaming, structured outputs, prompt versioning, per-feature evals). Each tool is a thin Next.js app on top, deployed independently. A bug in one tool can't take down another, but they all share identity, data contracts, and the AI infrastructure.
Shared backboneThin appsShip in days
Architecture
One shared backbone.
One shared backbone — auth, data, design, AI primitives — with each tool shipped as an independent Next.js app on top. Independent deploys, shared data, zero cross-tenant leakage.
Apps
8 independent Next.js apps
Per-tool subdomain
Per-tool deploys
Shared design language
Shared UI
TypeScript component library
Design token system
Accessibility primitives
Dark mode + theming
Shared Backend
Supabase Postgres
Row Level Security
Edge functions
Shared auth + JWT
AI Layer
LLM streaming
Structured output
Prompt versioning
Per-feature evals
Embeddings + pgvector
One request, start to finish
User signs in once on any tool
Shared auth issues a JWT scoped to that identity
Every tool validates the same JWT server-side
Postgres RLS enforces tenant isolation on every query
LLM features stream back to the UI with structured outputs
Decisions
Five calls and why I made them.
Call 01
Independent deploys, shared data
Tools fail differently and iterate at different speeds. Coupling their deploys would have turned every release into a coordination problem. Each tool ships on its own CI; only the data contract is shared.
Call 02
Row Level Security at Postgres, not the API
Multi-tenant data with AI in the loop is a leak waiting to happen. Enforcing tenant isolation at the database layer means a bug in any API route — or any future tool — can't cross user boundaries. Defense in depth, not trust in one layer.
Call 03
Component library is the real product
The leverage isn't any one tool — it's the shared library. Investing in primitives (theme, a11y, form patterns, loading states, empty states) made each new tool feel finished on day one instead of needing weeks of UI polish.
Call 04
One shared auth across all surfaces
Sign in once, use all. Separate auth per tool feels like enterprise IT circa 2010. One identity across the suite is the single biggest UX decision — and it's only possible because of the shared backend.
Call 05
LLM integration as reusable primitives
Streaming, structured output, prompt versioning, and per-feature evals show up in every AI feature. Codifying them once (with one wrapper, one eval harness, one prompt store) meant new AI features shipped in hours instead of weeks.
Reflections
What I took away.
The shared primitives are the real product
Every tool in Jishu Labs looks like its own app from the outside, but the part I spent the most time on is invisible: one auth flow, one Postgres with RLS, one component library, one LLM wrapper with streaming and structured output built in. When the eighth tool took me a weekend instead of a month, I realized the primitives were the actual product and the tools were just proof that they worked.
Dogfooding is a shortcut disguised as a hobby
I built these because I wanted to use them, not because I had a go-to-market plan. That let me skip the usual dance of user research and ship the version I personally needed on day one. Every tool that's survived is one I still open weekly. The ones I stopped opening got deleted. No better signal exists for a solo project.
Row Level Security is non-negotiable once AI is in the loop
Multi-tenant data and LLMs are a leak waiting to happen — one bad prompt and you're serving someone else's data as context. Enforcing tenant isolation at Postgres (not at the API layer) turned a category of terrifying bugs into an impossible class. Defense in depth isn't paranoid; it's cheaper than the alternative.
Outcomes
What shipped.
Tools8Live AI-augmented apps
Identity1Sign in once, use all
Backend1Shared infrastructure
Design1Unified design system
Stack
Technology
Frontend
Next.js
React
TypeScript
Tailwind CSS
Backend
Supabase
PostgreSQL
Edge Functions
AI
LLM-augmented features
Voice transcription
Embeddings
Infra
Netlify
Shared design tokens
Features
What it does
Multi-tenant Postgres schema with Row Level Security — one shared backend for 8 tools, zero data leakage between users
Shared TypeScript component library and design token system — new tools inherit identity, theming, and accessibility for free
Each tool deploys independently as its own Next.js app — fast iteration without breaking the others