/projects/pulse
← All projectsPulse
A live, real-time system embedded in a portfolio.
Design & implementation
Overview
A self-hosted portfolio that doubles as a live systems demo: presence, visits, and metrics travel through a real event-driven backend in real time, not canned data.
What I did
Solo project — the design, the event-driven backend, the front end, and the infrastructure it runs on.
- The realtime presence pipeline and its world map.
- The transactional outbox and the event-driven backend behind it.
- The public ops dashboard and the metrics it exposes.
- The AI assistant and the profile that grounds it.
- Deployment, from container build to the machine it lands on.
The problem
A CV asserts seniority and a repository demands that someone read it; neither lets a stranger watch a system work. Pulse closes that gap by being both the portfolio and the thing being demonstrated. The constraint it was built against was not a user need but an evidentiary one — make the claim checkable in the thirty seconds someone actually spends.
Architecture
A .NET backend behind a React client. A new connection resolves the visitor’s rough location and publishes a visit event through a transactional outbox, flushed in the same save as the write. A worker drains that outbox over RabbitMQ and appends the audit trail in Postgres. SignalR carries live presence — the connection count, and reactions — while the world map reads the accumulated visits by polling, so the map draws on its own schedule instead of blocking on that round trip. Tracing runs through OpenTelemetry, and the whole thing ships as containers behind Caddy.
- BrowserA React client holding a SignalR connection open.
- APIResolves the visitor’s rough location, publishes the visit, and broadcasts the new presence count to everyone.
- OutboxThe event is buffered and flushed in the same save as the write, so it cannot be published for something that did not commit.
- WorkerDrains the outbox over RabbitMQ and appends the visit to the audit trail.
- World mapPolls the accumulated visits on its own schedule, so the map never blocks on the round trip that fills it.
What it does
- Live presence via SignalR — see who else is on the site right now, on a world map.
- Event-driven .NET backend with a RabbitMQ transactional outbox, Postgres, and OpenTelemetry tracing.
- A public ops dashboard exposing real metrics — live connections, visits over time, and the event feed as it happens.
- An AI assistant grounded in a maintained profile, streaming answers about the author.
- Deployed with Docker Compose + Caddy behind Terraform-managed infrastructure.
Engineering decisions
A transactional outbox behind a visit counter
Nothing about counting visits requires one. The point is not the counter — it is that the pattern is here, wired end to end, in something a reader can watch rather than a diagram they have to trust. On a product this would be over-engineering; on a demonstration it is the deliverable.
Real telemetry, published
The ops dashboard exposes the system’s actual numbers, which means a reader can catch the site lying about itself. Most portfolios make claims that cannot be checked; this one chose the version that can be.
Prerendered pages over a client-only app
The site renders its content into HTML at build time, so a first visit does not wait on JavaScript and a crawler sees the same page a person does — and, usefully, a deploy can be verified with a single request rather than a browser.
An assistant grounded in a maintained profile
The assistant answers from a file the author keeps current, and says it does not know rather than inventing. Ungrounded, it would be a demonstration of exactly the wrong thing.