PULSE is a full-stack SaaS platform that moves beyond traditional project tracking by computing work pressure, silence, and drift in real time rather than storing static state. The platform demonstrates deliberate architectural decisions: tenant isolation enforced by PostgreSQL row-level security as a backstop behind application filters; real-time collaboration built on LISTEN/NOTIFY primitives rather than third-party message brokers; pressure signals derived at read time from activity logs rather than computed on a schedule; and a design system where every color carries its measured WCAG contrast ratio in source. Built with Next.js, React, PostgreSQL, and Drizzle ORM, PULSE encompasses 26,200+ lines of application code, 47 components, 23 database tables (16 protected by RLS), and ~11,000 lines of Playwright verification covering drag-and-drop, live sync, and tenant boundary scenarios.
Built with: Next.js, PostgreSQL, React, Drizzle.
23 tables with 16 enforced by PostgreSQL row-level security under one shared isolation policy. The application connects as pulse_app, a role that owns no objects and is subject to RLS by construction. Every table carries a one-line policy checking organization_id via current_setting, with no bypass GUC available. Application-layer WHERE filters serve as the control; RLS serves as the backstop, demonstrating defense-in-depth security at the schema level.
One Postgres LISTEN/NOTIFY channel drives a single Server-Sent Events route with one client hook. Events fire only on commit, guaranteeing a client never observes an event before the change is durable. Events carry metadata (seq, verb, projectId, taskId) only, never data payloads, forcing clients to re-fetch through the same authenticated, visibility-checked queries that governed the page. Zero Redis pub/sub, zero third-party realtime vendor.
All pressure signals (overdue, due now, stalled, carried) are computed at read time from the activity log rather than stored as state, preventing staleness. A recordActivity function is the single writer to the activity table; every mutation records its event in the same transaction as the change itself. The activity log serves as the source of truth for the feed, notifications, dwell-time history, and trace sparklines without any disagreement.
Reordering a board integer-by-integer renumbers every row after the insertion point — which turns optimistic drag-and-drop into a lie, since the client can't predict the server's renumbering and the card visibly snaps back. PULSE uses fractional indexing instead: a lexicographically sortable string key, so inserting between two cards produces a key strictly between them without touching any other row. One drag, one row write, and the optimistic position is always the final one.
Every mutation records its own event inside the same database transaction as the state change it describes. Exactly one function in the codebase is permitted to write to the activity table. That single rule is what lets the trace, the feed, notifications, and dwell-time history all read from one log without ever disagreeing — a log a state change can outrun is worse than no log at all.
The brand palette, measured plainly, is an ink palette — its signature red scores 1.24:1 against the dark surface it was designed for, well under the 3:1 floor for legibility. Rather than force it, the system uses two surfaces on purpose: dark instrument panels carry brand hues as tinted strokes at graded opacity, while light paper panels carry those same hues at full literal strength as ink, where they clear AA outright.
Before PULSE, project tracking platforms lacked the ability to detect work stalled in-flight; a dormant board was indistinguishable from quiet convergence. Tenant isolation relied entirely on application code, leaving each production deployment one missed WHERE clause away from a cross-tenant data leak. Real-time collaboration required adding a third-party service like Pusher or Socket.io, introducing a new vendor dependency, an additional bill, and a new failure mode. Risk signals like "at risk" or "overdue" were computed on a schedule and stored as state, becoming wrong the moment the clock advanced and no cron job re-ran. Complex filtering and grouping controls were often overloaded into a single UI element, making it unclear what restrictions were actually applied. Drag-and-drop reordering required renumbering rows, making client-side optimistic updates always incorrect and causing visible snap-back after the server response.
PULSE ships with real-time pressure signals computed at read time from the activity log, making them structurally incapable of going stale. Tenant isolation is enforced twice: an explicit filter in every query paired with PostgreSQL row-level security as a backstop that catches forgotten filters by construction. Real-time collaboration flows through a single LISTEN/NOTIFY channel and Server-Sent Events route with no message broker; events are commit-guaranteed and carry only metadata, forcing clients to re-fetch through authenticated, visibility-checked queries. Drag-and-drop uses fractional-index order keys, requiring only one row write per drag with the optimistic client position always correct. The design system is measured, with every color carrying its computed WCAG contrast ratio in source, ensuring legibility across both dark instrument panels and light paper surfaces. The activity log is the single source of truth for all derived features, preventing disagreement between the trace, feed, notifications, and dwell-time history.
PULSE demonstrates that full-stack engineering means more than integrating existing libraries and frameworks. It shows the difference between inheriting architectural defaults and making deliberate choices: storing tenant isolation at the database layer as a backstop behind application filters rather than trusting code alone; building real-time from a database primitive already running instead of reflexively adding a third-party broker; treating staleness as an architectural problem with a real answer (derive signals at read time) rather than a caching problem to paper over; and shipping a design system with its accessibility math shown in source, not asserted in a guide. The codebase demonstrates this discipline across 26,200+ lines of application source, 47 React components, 23 database tables (16 protected by RLS), 273 automated unit tests, and ~11,000 lines of Playwright verification driving real drag-and-drop, live sync, and tenant-boundary scenarios. Every figure is measured directly from the repository, not projected. This is what a senior full-stack engineer's default settings look like when nothing is templated and nothing is left for code review to catch.
Live site: https://pulse-five-pi.vercel.app/