Hamza
Saied

Challenge: Modern multi-socket servers expose NUMA topology where remote memory access is materially slower than local. Existing caches (Redis, Memcached, Meta CacheLib) ignore NUMA and use static coarse-grained sharding. No production-grade cache treats NUMA topology as an adaptive input to per-page placement combined with a contention-aware eviction policy.

Approach: Designed and implemented a C++20 cache with per-node physical block allocation, PMR-backed containers, and per-node sharded KeyStore. Used SeqLock-based lock-free reads to remove synchronization from the read path, and replaced ARC with S3-FIFO using a per-slot atomic frequency counter for lock-free hit tracking at zero extra memory. Added SIMD-accelerated hashtables with seqlock torn-read protection, cooperative lock draining, and NUMA-aware memory placement as a first-class design input. Validated on real multi-socket hardware (EC2 c6a.metal and c6i.metal) and authored a technical whitepaper (v1.28.0) with DOI on Zenodo.

Outcome: 19× throughput over Meta CacheLib on EC2 c6a.metal — 14.3M ops/s vs 740K ops/s, both systems with full eviction. Earlier validation on EC2 c6i.metal (2 sockets, 128 vCPUs) showed lock-free reads expose 2.3× more cross-node overhead than shared_mutex, confirming NUMA placement as the dominant signal. Also demonstrated empirically that ARC's adaptive parameter collapses under thread contention — a failure mode absent from the original SOSP 2003 paper's single-threaded assumptions.

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 the migration architecture, selected Ristretto for caching, built a shared library used across 12 supplier microservices, and implemented TravelLanda V2 booking lifecycle handlers across two summer internships.

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.