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 memory topology, and CacheLib handles it with static per-domain sharding that does not adapt to where a page is actually accessed.

Approach: Designed and implemented a C++20 cache with per-node physical block allocation, PMR-backed containers, and per-node sharded key stores. Used SeqLock-based lock-free reads to remove synchronization from the read path, and a concurrent Swiss table with SSE2 SIMD probing and per-slot seqlock concurrency as the backing store for the ARC policy, with deferred promotions through a lock-free MPSC buffer.

Added staging pages so the write path has an O(1) fast path decoupled from eviction, and benchmarked an S3-FIFO policy with a per-slot atomic frequency counter against LRU.

Validated on real multi-socket hardware (EC2 c6a.metal, AMD EPYC Milan, 4 NUMA nodes, and c6i.metal, Intel Ice Lake) and published the design and evaluation as a technical report with a Zenodo DOI.

Outcome: Measured 22x lower p50 GET latency and 10x higher throughput than Meta CacheLib on YCSB-A (64B values, 2 threads, 32MB usable cache, Zipfian theta 0.99, 10 repetitions) on EC2 c6a.metal, and 1.5x to 9.5x lower p50 GET latency across the capacity and value-size sweep at equal usable capacity, with 100% versus 50% memory efficiency.

Diagnosed a false-sharing bug where alignas(64) statistics atomics caused cross-socket cache-line bouncing, cutting 4-thread p50 GET from 587ns to 71ns.

Kept the companion REMARC policy framework in the report as a documented negative result: it added no measurable value over simple EMA counting.

Challenge: Financial data onboarding needs traceability before every write.

Spreadsheets arrive with drifting schemas, mixed date and number formats, and row-level errors that surface only after parsing, in a sector where each imported record must stay explainable.

Approach: Designed a five-step Angular 21 and DevExtreme wizard that selects the target entity, validates the upload, maps columns to database fields with reusable saved mappings, previews the transformed rows, and gates the write behind a human review.

On the server, a Clean Architecture .NET 10 backend pairs a streaming ExcelDataReader pipeline with a single-transaction binary COPY, runs the pre-flight dry run on a separate queue through the same parse and evaluation core, enforces per-entity validation rules, and writes a two-tier audit journal holding per-batch totals and per-row snapshots.

Upload handling rejects macros, inspects the OOXML package, caps declared sizes, and stores files under generated names outside the webroot.

Delivered during an internship at Axley Bankers, then continued independently with a batch-first journal, per-table concurrent imports, and distinct validating and copying phases.

Outcome: Verified a 60 MB workbook of 1.1 million rows ingested end to end through the dev server.

Automated suites cover the domain layer, the application layer, functional paths against a real PostgreSQL, and browser specs in headless Edge, with every suite green.

The delivered V1 ships with French technical documentation and a user guide rendered to PDF with Quarto and Typst.

Challenge: A student team project needed a scalable architecture and operational discipline, with inconsistent coding practices and cross-module coupling risk across modules.

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, and led the architecture direction for the team.

Outcome: Improved maintainability and team delivery safety by preserving strict module contracts, while shipping a team project to a dedicated VPS with repeatable deployment workflows.

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

Plus a rebuild of an earlier codebase with clearer module boundaries.

Approach: Rewrote the engine in C++20 around a Vulkan backend, a resource pipeline, and a scene loop.

Kept the engine core, the IO layer with its virtual filesystem, and a separate sandbox target apart, and held the build to strict CMake and vcpkg dependency hygiene.

Outcome: Built as a deliberate practice project: a structured engine core with a Vulkan backend, shaders, an IO layer with a virtual filesystem, and a documentation site.

The scripting API, multithreaded rendering workflows, plugin architecture, and additional graphics backends are still on the roadmap.

Challenge: Backend latency and slowdown issues persisted under supplier load.

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 the rented production fleet from 4-7 servers to one internal server, which relocates that cost onto internal hardware rather than removing it.

Established a lower-latency gRPC architecture with a shared library used across 12 supplier microservices.

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.