Correctness first
Invariants live in domain types, policy lives in app services, and infra owns SQL + hashing.
- Typed boundaries and newtypes for critical data
- Explicit error mapping across layers
eran.codes platform
A production-ready Axum stack with signed sessions, SQLx persistence, and Datastar-powered UI.
How I Think About Systems
This portfolio emphasizes engineering judgment: correctness, clarity, and maintainability over surface area.
Readable by design
Builder pipelines and componentized Maud views keep call sites self-documenting.
- Bon builders with descriptive steps
- Reusable UI components (Render + enums)
Maintainable over time
Tracing, linting, and module READMEs turn architectural decisions into guardrails.
- Live + diagnostic trace logs
- CI checks for stringy logic + render coverage
Architecture Audit (What This Site Demonstrates)
A concise, end-to-end review of storage, representations, interactions, and idiomaticity across the workspace.
Storage layers
Durable state in Postgres, transient state in SSE + in-memory logs, UI derived via Maud.
- DB: users, credentials, chat rooms/messages, sessions, audit
- In-memory: per-request + per-session trace buffers
- UI: Maud components render typed values
Representations in code
Each layer owns its types to enforce invariants and boundaries.
- Domain: newtypes + invariants, no serde/HTTP/DB
- App: commands + traits for orchestration
- Infra: SQL rows + concrete hashing
- HTTP: DTOs + Renderable components
Interactions
Request flow is explicit, traceable, and layered.
- HTTP parses -> App orchestrates -> Infra persists
- SSE fanout for chat messages
- Live vs diagnostic trace logs
Idiomaticity & guardrails
The codebase encodes standards as lint, builders, and docs.
- Bon builders keep wiring readable
- Render components + enums (no stringly logic)
- CI checks: stringy logic, String fields, Render coverage
- Module READMEs for architecture mapping
Feature gallery: realtime delivery, grounded in systems
A quick visual scan of the core capabilities, followed by live diagrams that explain how requests and events flow through the stack.
Realtime chat fanout
SSE push with durable message storage and moderation gates.
- Postgres-backed message history
- Per-room moderation queues
- Single SSE stream per session
Session durability
Signed cookies + DB sessions keep identities consistent.
- Encrypted session cookies
- User id attached to tracing
- Session store persistence
Boundary-safe flows
Typed DTOs, commands, and domain invariants protect policy.
- Domain invariants via newtypes
- App commands orchestrate policy
- Infra owns SQL & hashing
Observability woven in
Spans, trace logs, and live network views in one place.
- Structured request spans
- SSE event visibility
- Request grouping by trigger
Realtime request flow
What happens when a user sends a message.
POST /demo/chat/messagesAccepted · 202
App: rate limit + moderationok · queue=clean
DB writechat_messages
Rate limit windownear cap
SSE broadcastappend .chat-messages
Identity + session durability
Signed cookies keep a single SSE stream per visitor.
session_id cookiesigned · http-only
session storepostgres
sse streamone per visitor
Boundary handoff
Each layer owns its responsibilities.
HTTP DTOrequest parsing
App commandpolicy + orchestration
Domain typesinvariants
Infra repoSQL + hashing
Live backend log (SSE)
Actions above stream real request, trace, and DB events into this log via SSE.
No events yet. Trigger a demo action to start streaming.
Live network log (SSE)
Server-side request timings emulate a network tab view.
No requests yet. Trigger a demo action to populate this table.
Demo D: Live Chat System (Capstone)
Enterprise chat flow with persistence, moderation, and SSE fanout.
- Messages are stored in Postgres and reloaded on entry.
- Rate limiting + moderation queue are enforced in the app layer.
- SSE broadcasts updates to all connected visitors.
Live chat room
Sign in to send messages and see the chat room.