projects

Selected engineering work in real-time collaboration, distributed infrastructure, and storage-engine design.

Each case study summarizes the architecture, implementation, validation strategy, and measurable technical results.

collaborative systems

flagship project

SyncPad

permission levels

owner / editor / viewer

A production-oriented collaborative rich-text editor with durable document state, multi-layer authorization, and real-time comments.

Next.js client renders the dashboard and editor, connects Tiptap to Yjs, and manages permission-aware interface states
Spring Boot API owns document CRUD, sharing, authorization, comment persistence, and Flyway migrations
Hocuspocus service authorizes WebSocket sessions and synchronizes Yjs document and awareness state
PostgreSQL stores documents, permissions, comments, and collaborative state; Redis supports transient coordination

Tiptap and Yjs provide conflict-free rich-text editing, presence, synchronization state, and reconnection behavior
Owner, editor, and viewer permissions are enforced independently by the REST API and collaboration service
Inline comment threads support replies, resolution, reopening, filtering, and real-time updates
The dashboard supports document CRUD, invitations, sharing controls, and permission-revocation handling
Frontend, collaboration-service, backend, Testcontainers, Flyway, and Playwright checks run through CI

Next.js / React / TypeScript / TipTap / Yjs / Hocuspocus / Spring Boot / PostgreSQL / Redis / Clerk / Docker / Playwright

distributed infrastructure

263,826

successful checks

zero failures under load

A distributed API gateway that enforces shared request quotas across horizontally scaled Go instances using Redis-backed token buckets.

Nginx distributes requests across three stateless Go gateway instances using round-robin load balancing
Each gateway identifies the client, selects a route policy, and proxies accepted requests with httputil.ReverseProxy
Redis stores global bucket state; Lua performs each read, refill, decision, and update atomically
Prometheus collects request, rejection, Redis-error, and latency metrics for Grafana visualization

Atomic Redis Lua scripts prevent race conditions while refilling, decrementing, and persisting shared token buckets
Client quotas use the X-API-Key header when present and fall back to IP-based identification
Route-specific policies define independent capacities and refill rates for default, search, and admin endpoints
Configurable fail-open and fail-closed modes make the Redis availability tradeoff explicit
Prometheus metrics, Grafana dashboards, k6 correctness tests, and Docker smoke checks cover operational behavior

Go / Redis / Redis Lua / Nginx / Docker Compose / Prometheus / Grafana / k6 / GitHub Actions

storage engine

>100k

operations / second

measured benchmark throughput

A high-performance, Redis-inspired key-value store implementing concurrent networking, persistence, expiration, and bounded-memory behavior in Go.

Concurrent connection handlers parse TCP commands and route read, write, and snapshot operations
An RWMutex-protected in-memory store manages key access, TTL state, and configurable LRU eviction
Mutations are appended to the write-ahead log before they are applied to memory
Startup recovery loads the latest snapshot, replays the WAL, removes expired keys, and then accepts traffic

TCP protocol supports PING, SET, GET, DEL, EXPIRE, TTL, DBSIZE, STATS, SAVE, QUIT, and EXIT
TTL values use absolute expiration timestamps and a background worker removes expired keys
Configurable WAL sync policies expose durability and write-throughput tradeoffs
Snapshot creation compacts persisted state and truncates the write-ahead log
End-to-end TCP recovery tests, Docker builds, benchmarks, and GitHub Actions validate the system

Go / TCP / Docker / GitHub Actions