work / internal app / internal operations platform

One platform, many builders, zero chaos.

A US services group ran on scattered spreadsheets, and many staff were building their own tools with AI. I designed, built and run the internal platform that replaced the spreadsheets, and made it safe for everyone to build on.

role
Solo architect & developer
client
US multi-entity services group
status
Live in production

Languages

TypeScriptSQLJavaScriptCSS

Tools & platforms

ReactViteReact RouterTailwind CSSTanStack QueryReact Hook FormZodSupabase (Auth, Realtime, Storage)PostgreSQLDeno Edge Functionspnpm / TurborepoFirebase HostingGitHub ActionsDependabotVitestTesting LibraryPlaywrightESLint / PrettierSentry

AI & LLM

in the product
Claude API (summaries and drafting)
to build it
ClaudeChatGPTPerplexity

Skills

System architectureRow-level securityMulti-tenant designCI/CDAutomated testingDeveloper guardrails
01// how I approached it

The thinking behind it

  1. 01 · What I noticed

    The real problem wasn't missing tools. Everyone was building their own, in their own shape, with their own database access.

  2. 02 · What I decided

    Build one platform where every app has the same shape, and make the rules part of the build so nobody has to remember them.

  3. 03 · What I delivered

    A governed platform with database-level security, now live and safe for many builders.

02// old vs new

Old system vs new system

Old systempeople as the glue
  1. Find the right spreadsheet
  2. Ask for access
  3. Email a request
  4. Chase for updates
  5. Fix broken formulas
New systemthe system does the work
  1. Sign in once
  2. Admin approves the account
  3. Open your role's apps
  4. Track requests live
03// how it works

Watch it run

Click through the four steps. In step 3, click any box to see what it does.

synthetic data · no client screens
Reconstruction with synthetic data · no client screens
04// the hard part

The hardest problem was people, not code.

Many staff were building tools with AI, and each wanted theirs inside the portal. Every tool arrived in a different shape: its own layout, its own look, its own database access. Code review alone couldn't keep up, so I made the structure enforce itself. Pick a mistake to see what the build does.

  

Also enforced: Git hooks block commits straight to main · a changelog and skill files teach the next person and the next AI session the rules.

05// security, rebuilt with fake data

The database says no, not just the screen.

Switch roles and try opening an app. Hidden buttons are easy to get around; here every table has its own access rules, so even a direct request for the data is refused.

portal.example / home

database check

Pick an app to see the database decide.
Recreation with fake roles and data. 3 of the 8 real roles shown.
06// system size

Built and run by one person

1

developer

architecture to production
206

security rules

every one of 64 tables protected
125

production releases

each tested on staging first
111

database changes shipped

versioned, all live in production
6

data domains

isolated by role and business entity
12

server functions

admin, syncs, email, AI

Source: read-only query on the live database and the repository, Oct 2026.

07// key decisions

Why it's built this way

decision 1

Access checked in the database, not just the screen

Even if someone finds a hidden page, the data itself refuses to load for the wrong role.

Trade-off: more upfront work on permission rules.
decision 2

One codebase, separate modules

Each business app loads only when opened, but shares login, design and data code.

Trade-off: stricter structure than separate small apps.
decision 3

Staging before production, every time

Changes go to a test site with no real data, get reviewed, then deploy by hand.

Trade-off: slower releases, far fewer surprises.
front endReact + TypeScript modular monolith. Each business app is a lazy-loaded module with the same four-part shape.
dataPostgres with row-level security on every table and per-entity isolation. All table access goes through one shared package.
serverEdge Functions for user admin, warehouse and sheet syncs, email and AI summaries.
deliveryBranch → staging with no real data → review → manual production deploy. CI, dependency updates, error monitoring.
08// lessons

What made it work

  1. 01

    Rules beat reminders

    When many people (and AIs) build on one system, put the rules in the build. A clear failing check teaches faster than any doc.

  2. 02

    Design for the next builder

    Skill files, a changelog and a runbook mean the next person, or the next AI session, learns the rules without asking anyone.

  3. 03

    Ship small, ship often

    125 production releases, each through staging first. Small, reviewed changes are how one person keeps a big system calm.