PhsarOS

Problem

Small retailers need a fast, atomic point-of-sale system connected to a live operations dashboard without the enterprise bloat. They often resort to pen and paper because existing tools are slow, overly complex, or require expensive hardware.

My role

I engineered the entire platform end-to-end. I designed the multi-tenant schema, built the transactional checkout, and developed the type-safe UI.

What I built

• — Live operations dashboard with KPIs, a 7-day revenue chart, and recent sales
• — Point of Sale with a searchable grid, mobile order bar, and bottom order sheet
• — Atomic transactional checkout with real-time change calculation
• — Inventory management with bottom-sheet forms and mobile card layouts
• — Mobile-first shell: top status bar + bottom tab nav
• — Persistent night mode: app-level theme controller with dark tokens across every route
• — A server-rendered dashboard (React Server Component) so data lands in the first paint with a skeleton, not a loading flash
• — Accessible drawers and modals: focus trap, Escape-to-close, and ARIA dialog roles

Architecture

PhsarOS is a Next.js 14 App Router app where the backend is expressed as type-safe Server Actions calling Prisma against Neon serverless Postgres, avoiding a separate REST/GraphQL layer. The checkout path is deliberately modeled as one Prisma transaction so a sale, its line items, and stock decrements either all commit or all roll back — chosen over offline-first capability as the priority tradeoff. A Prisma driver-adapter setup lets the same schema run on SQLite locally and Neon in production by swapping a single adapter, and the dashboard uses React Server Components so KPI data is present at first paint rather than after a client fetch.

A Vercel-hosted dashboard backed by Neon Postgres serverless. It uses a custom design-token system, optimistic UI, and keyboard-first navigation for rapid cashier workflows.

Backend / deployment

Constraints

• — Must be keyboard-first for rapid cashier workflows
• — Checkout must be a single atomic transaction
• — Needs a multi-tenant-ready relational schema

Tradeoffs

• — Prioritized atomic transactions over offline-first capability
• — Used Next.js App Router which adds some hydration complexity but significantly speeds up server-side data fetching

What I learned

• — Type-safe end-to-end development via Server Actions (eliminating REST/GraphQL boilerplate)
• — Executing checkout as a single Prisma transaction (sale + items + stock decrement)
• — Server-side Zod validation on every mutation
• — Driver-adapter architecture: swapped SQLite for Neon Postgres by changing a single adapter
• — Building responsive, mobile-first touch interfaces with Tailwind CSS
• — Implementing a robust light/dark theme token system across a complex dashboard

Next backend step

Repair the hosted demo instance (fix the failing runtime/DB env so the public URL serves the dashboard again), then add authenticated multi-tenant scoping and audit logging on top of the existing schema.