A high-performance database firewall and connection pooler that intercepts PostgreSQL wire protocol messages to block destructive SQL operations and optimize query pipelines with sub-millisecond overhead.

• Protocol-layer query interception for PostgreSQL wire traffic with destructive SQL blocking before execution.
• Connection pooling and persistent session handling tuned for low-latency database routing and request shaping.
• Designed to reduce operational risk by stopping destructive statements like DROP, DELETE, and ALTER TABLE at the socket boundary.

A multi-threaded C++ execution engine built on a lock-free Chase-Lev work-stealing deque and MPSC mailbox architecture. Delivers sub-5µs P50 latency under high thread contention.

• Lock-free work-stealing queue for contention-aware task dispatch under high thread count.
• MPSC mailbox design to minimize lock churn while preserving predictable throughput.
• Cache-aligned data structures and zero-allocation hot paths tuned for sub-5µs median latency.

A C++ arena allocator featuring custom bump-pointer mechanics, strict CPU cache-line alignment, and zero-fragmentation region resets.

• Linear arena allocation with deterministic lifetime management for high-throughput workloads.
• Cache-line aligned region sizing to reduce false sharing and improve locality.
• Bulk reset semantics for temporary object lifecycles without allocator fragmentation.

A thread-safe mark-and-sweep garbage collector in C++ featuring VM stack root scanning and automatic heap tracing.

• Conservative root discovery with stack scanning to locate live object references across threads.
• Automatic heap traversal and mark-state propagation to reclaim unreachable memory safely.
• Thread-safe collector internals designed around OS-level memory primitives and runtime tracing.

A multi-process monolith for trimming clips. The Express API offloads heavy yt-dlp + FFmpeg work to BullMQ workers backed by Redis, streaming real-time progress over WebSockets.

• Multi-process API and worker architecture for resilient job execution.
• Real-time job status streaming via Socket.io and Redis-backed queues.
• Optimized background job orchestration for bursty workloads and large video-processing pipelines.

A low-level WebSocket protocol implementation that performs RFC 6455 upgrade handshake and parses/encodes frames manually.

• Manual RFC 6455 handshake and frame parsing for protocol correctness.
• Raw POSIX-socket networking designed for low-overhead, high-concurrency communication.
• Ping/pong and control-frame handling with a focus on protocol fidelity and performance.