Hamza
Saied

Challenge: Modern multi-socket servers expose NUMA topology where remote memory access can be 1.2-2x slower than local. Existing caching systems (Redis, Memcached) ignore NUMA entirely; CacheLib uses static coarse-grained sharding. No published system combines NUMA topology as an adaptive input to per-page cache placement with an eviction policy.

Approach: Built a C++20 library with per-node physical block allocation, PMR-backed containers, bump-packed multi-value pages, and per-node sharded KeyStore. Implemented lock-free reads via SeqLock to eliminate synchronization overhead from the read path. Designed round-robin and thread-local key routing strategies. Created a 5-step ablation study isolating each architectural decision, a shared-nothing MPSC queue variant, simulated NUMA latency injection, and a cross-VM baseline isolation methodology. Published a technical whitepaper with DOI on Zenodo.

Outcome: Demonstrated that SeqLock lock-free reads expose 2.2x more NUMA signal than shared_mutex (11.7% vs 5.1% p50 cross-node overhead). Thread-local routing with SeqLock achieves 26-41% improvement over round-robin. Per-node sharding provides 3x concurrent Set throughput via lock partitioning. Ablation study isolates each design decision's contribution. Shared-nothing variant defines break-even at ~21 cache misses per operation on Xeon hardware.

Challenge: The project needed a scalable architecture and operational discipline in a team setting with inconsistent coding practices and cross-module coupling risk.

Approach: Designed a microservice-inspired modular backend architecture (implemented as a modular monolith due to project constraints), owned SRV and most Common shared layers, and enforced controller-mediated module boundaries. Built and maintained the full DevOps repo and VPS deployment workflow.

Outcome: Improved maintainability and team delivery safety by preserving strict module contracts, while shipping a production-hosted platform on a dedicated VPS with repeatable deployment workflows.

Challenge: Needed deeper control over rendering internals and frame pacing than off-the-shelf engines provide.

Approach: Built a custom Vulkan renderer, resource pipeline, and scene loop from scratch while keeping strict project structure, CMake workflows, and dependency hygiene.

Outcome: Produced a reusable graphics foundation and implemented advanced C++ smart-pointer internals with CAS-based promotion and co-allocated control blocks.

Challenge: Backend latency and slowdown issues persisted under supplier load, and the Node.js/REST architecture required 4-7 servers to handle peak traffic with unpredictable performance.

Approach: Proposed and defended migration direction from Node.js/REST to Go and gRPC, using goroutines as the core concurrency strategy. Co-designed migration architecture, selected Ristretto for caching, authored early shared common foundations, and implemented TravelLanda V2 booking lifecycle handlers across two engagement cycles.

Outcome: Reduced production server count from 4-7 down to 1, while establishing a lower-latency architecture with strong operational foundations and measurable runtime gains in targeted flows.

Challenge: Booking paths needed robust room allocation and occupancy-aware matching to avoid supplier-response mismatches and lifecycle inconsistencies.

Approach: Implemented and evolved RoomPacking/classification logic, then reinforced book/confirm/cancel/check-rate edge paths with validation and mapping safeguards.

Outcome: Improved production booking reliability through stronger allocation heuristics, passenger/occupancy checks, and consistency controls across supplier-facing workflows.

Challenge: Local build workflows were slow and repetitive when only a subset of files changed, wasting developer time in both local development and CI/CD pipelines.

Approach: Designed a Go CLI using Cobra with delta tracking, baseline snapshots, and command-based workflows. Scout monitors files and directories, detects changes since the last run, and executes only the tasks that actually need rerunning.

Outcome: Shortened feedback loops by eliminating redundant builds, with planned support for dependency awareness, parallel execution, and compiler/test runner integrations.

Challenge: High-throughput stream processing needed a lightweight threading model without heavyweight dependencies or complex build requirements.

Approach: Implemented core synchronization and pipeline primitives in modern C++20 with concepts-based type constraints, a task scheduler, and a small footprint designed for straightforward integration into any C++ project.

Outcome: Provides a reusable, dependency-free foundation for concurrent workflows with clean CMake integration and test coverage across all primitives.