← All work
In progress Solo · Full-Stack & Platform Engineer · 2026 — Present

School ERP — Multi-Tenant Platform for Indian Schools

A solo build to teach myself production-grade system design end to end — a multi-tenant platform that runs an entire school (admissions, academics, fees, payroll, transport, hostel, library, and a parent portal). Backend, two web consoles, and ~15 modules are built and tested on a fully open-source, no-Docker stack.

  • NestJS
  • Prisma
  • PostgreSQL
  • React
  • Tailwind
  • React Native
  • Redis / BullMQ
  • MinIO
Live — school app ↗ Live — provider console ↗

School ERP is my most ambitious solo build — and a deliberate one. I’m engineering a real, multi-tenant platform end to end, the way a production system is actually built, to learn the hard parts of system design rather than to ship a demo. Every layer runs on open-source infrastructure, and none of it needs Docker or a paid service to run.

What it is

A single platform that runs a whole school from one place — admissions and student records, academics (timetable, attendance, exams, report cards), fees and accounts, HR and payroll, inventory, transport, library, and hostel — plus a data-scoped parent portal. It’s built mobile-first and regional-language-ready: English, Kannada, and Hindi from the start.

How I’m building it

  • Multi-tenant at the core. One deployment serves many schools, isolated by tenant on a shared PostgreSQL database. Isolation is enforced at the data layer through Prisma middleware — not left to individual handlers — with deny-by-default role-based access control and per-row data-scoping, all backed by cross-tenant isolation tests.
  • A control plane, separate from the data plane. A dedicated provider console (its own auth realm) provisions schools, toggles each module on or off per school, and gives read-only cross-school oversight and analytics — code that can never reach a school’s own browser.
  • Module-based architecture. Around fifteen departments — SIS, admissions, attendance, fees, exams, timetable, HR, payroll, inventory, transport, library, hostel, and communication — each an independently toggleable module a school runs only if it needs it.
  • Config over code. Per-school feature flags, settings, branding tokens, and a tenant-keyed extension registry — customization happens through configuration instead of forks. Core never imports tenant code.
  • Two web frontends + a mobile app. A provider admin console and a school-facing web app are both built and browser-verified; a React Native (Expo) app for parents and teachers is scaffolded and will reuse the same tenant API the parent portal already exposes.
  • Open source, no Docker. NestJS + Prisma + PostgreSQL with Redis/BullMQ, MinIO, and Mailpit, all run natively on the machine through a make dev loop. External providers — email, storage, payments, SMS/WhatsApp, push — sit behind interfaces with mock/OSS adapters, so the whole thing develops with nothing paid.

Doing it properly

The point is the rigor, not the feature checklist: money handled as integer paise that reconciles to the paisa, append-only audit trails on every sensitive mutation (grades, fees, payroll, admissions), fail-fast env and secrets handling, PDF generation for receipts and report cards, and a per-component lint / typecheck / test / build gate. The test suite is real — around 375 end-to-end tests across ~58 suites (including tenant-isolation and control-plane boundary checks) plus unit and frontend tests, run on every change. Treating that discipline as the real deliverable is the whole reason I’m building this.

Deployed, end to end

It’s live on a fully self-managed, $0 open-source stack — the backend and PostgreSQL on a free cloud VM behind automatic HTTPS (Caddy + Let’s Encrypt), S3-compatible object storage, and both web consoles on edge hosting. Standing it up by hand — DNS, TLS certificates, a Linux service, production migrations and seeding — was its own lesson in the operations half of “production-grade.” The two consoles linked above are live; demo credentials are available on request.

Recent depth

The richer modules keep getting deeper rather than wider. Exams now has a full assessment engine — weighted components (FA/SA-style), co-scholastic/CCE grades, and per-component report-card breakdowns that freeze into an immutable snapshot when a card is published. The SIS gained academic-year rollover: preview the promotion plan, advance each student to the next class by rank, graduate the top class, and fail loud rather than silently skip when a class is missing a section. Fees grew an outstanding-dues / defaulters report with overdue tracking. Config-over-code is real too — per-school feature flags, settings, and custom fields, all without a fork.

What’s next

From here it’s continued depth (exam moderation, fee carry-forward on rollover, statutory payroll), the provider-side CRM/billing/support on the control plane, and building out the React Native app on top of the tenant API the parent portal already exposes.