SYSTEM_ID: MY-ARCH-01 // PRODUCTION BACKEND & DISTRIBUTED SYSTEMS
//Mahmoud Younes — Software Engineer · Systems Thinker · Product Builder

I build systems, explore ideas, and turn complexity into software.

Senior Go engineer focused on backend systems, distributed architecture, and AI-powered products. I enjoy working across the stack, understanding complex problems, and building solutions from first principles.

LIVE_TOPOLOGY // CONCURRENT DISTRIBUTED PIPELINE MODEL
Zero-Alloc Buffering Active
INBOUND INGRESSHTTP/2 Gatewaycontext.WithTimeoutWorker Pool Async.WaitGroupGo Coroutine [0..N]Channel Fan-OutWorker Pool CBackpressure GuardProvider API 01HTTP/JSON 120msProvider API 02gRPC Stream 45msProvider API 03SOAP Adapter 310msIN-MEMORY REDUCERDedupe & RankZero-Alloc BufferEGRESSSSE / Redis< 380ms P99
* High-concurrency fan-out pattern with channel-buffered backpressure and live circuit breaking.Goroutines: Active · Race Detector: Passed
01 //BACKGROUND & ORIGINS

About Mahmoud

DISTRIBUTED SYSTEMS RESEARCH

I am a software engineer with nearly 5 years of professional experience primarily focused in Go (Golang), engineering fault-tolerant production systems, high-throughput microservices, and distributed pipelines.

Currently, I engineer core distributed search and inventory discovery systems at an online travel technology company. My day-to-day involves aggregating live inventory from multiple heterogeneous provider APIs, evaluating dynamic room availability and real-time pricing models, executing in-memory offer deduplication, and streaming sub-second optimized results under heavy concurrent user query loads.

I view systems through a first-principles lens: disassembling latency bottlenecks, ruthlessly eliminating extraneous abstractions, and designing software that remains resilient, testable, and straightforward to reason about when production nodes inevitably degrade or network partitions occur.

Production Profile // Real-World Performance

Multi-Provider Concurrency · Zero-Allocation Buffering · Low-Latency Search Workflows

P99 < 400ms10k+ QPS Ready
01. FIRST PRINCIPLES

Understanding kernel primitives, memory layouts, and OS networking yields simpler, more robust code than piling on heavy frameworks.

02. OBSERVABILITY FIRST

A system you cannot measure is an accident waiting to happen. Structured telemetry, distributed traces, and clear log contexts are table stakes.

03. AUTONOMOUS HYBRID

Pairing deterministic Go runtimes with nondeterministic LLM agent workflows to build reliable, real-world conversational & automation platforms.

// 02. CORE DOMAINS

Architectural Disciplines

Specialized engineering capabilities cultivated through mission-critical production systems and focused technical experiments.

DOMAIN_01 // RUNTIME

Backend Engineering

Building reliable, performant backend services with a relentless focus on high concurrency. Implementing scalable goroutine pools, resilient HTTP, gRPC, and WebSocket APIs, zero-downtime PostgreSQL migrations, and memory-conscious data serialization.

Go ConcurrencyGoroutine PoolsgRPC & RESTPostgreSQL
DOMAIN_02 // ARCHITECTURE

Systems Architecture

Designing distributed systems with careful partitioning, event-driven pipelines, multi-provider aggregation mechanisms, and strict concurrency primitives. Structuring layered caching strategies across Redis and Postgres with circuit-breaker resilience to absorb catastrophic upstream failure.

Distributed CachingRate-LimitingEvent-Driven ArchitectureCircuit Breakers
DOMAIN_03 // INTELLIGENCE

AI Engineering & Orchestration

Architecting autonomous agent workflows, dynamic tool-calling pipelines, stateful session graphs, and multi-agent coordination runtimes. Integrating real-time streaming speech-to-text (STT) and low-latency text-to-speech (TTS) with frontier LLM APIs inside production customer channels.

Multi-Agent StateDynamic Tool-CallingStreaming STT / TTSSession Graphs
DOMAIN_04 // EXPERIENCE

Product Engineering

Bridging low-level systems engineering with intuitive developer experience and customer-centric product architecture. Transforming complex technical constraints into clean APIs, predictable CLI utilities, and robust user-facing tools that solve real operational bottlenecks.

Developer ToolingAPI ErgonomicsCLI & TUI DesignClean Contracts
// 03. SELECTED WORK

Systems In Production

3 PRODUCTION CASE STUDIES · 3 GO PROJECTS
CASE_01/TRAVEL TECH PLATFORM
LIVE IN PRODUCTION

Distributed Hotel Search & Aggregation Engine

Real-time high-concurrency search pipeline engineered to aggregate live inventory, room rate plans, and dynamic cancellation policies across heterogeneous global travel provider APIs. The system reconciles disparate schemas, normalizes pricing, and streams valid offers directly to the booking layer.

Technical Highlights:
  • >Designed concurrent Go worker pools with context cancellation, deadline propagation, and per-provider rate-limit token buckets.
  • >Engineered an in-memory streaming offer reducer that eliminates duplicate hotel room inventory and scores rate parity in sub-linear time.
  • >Architected a multi-tier Redis caching hierarchy that reduced repeat lookup latency by 68% and shielded unoptimized upstream provider systems.
GoConcurrency PrimitivesRedis ClustersDockerOpenTelemetry
SYS_FLOW // SEARCH_AGGREGATIONFIG. 01
Client Search QueryFan-Out DispatcherSupplier A (REST)Supplier B (gRPC)Supplier C (XML)Streaming DeduplicatorZero-Alloc Room HashRanked SSE Result
THROUGHPUT:12,400 ops/sec
AVG_LATENCY:184ms
CASE_02/AI AGENT ORCHESTRATION
LIVE IN PRODUCTION

AI Customer-Service Agent Control Plane & Orchestration

Control plane and real-time orchestration backend powering AI customer-service agents across multi-channel customer interactions. Unifies agent configuration, channel routing, stateful session lifecycles, and streaming voice/LLM pipelines.

Technical Highlights:
  • >Built the control plane and orchestration/admin APIs for configuring, deploying, and managing AI customer-service agents.
  • >Developed event-driven backend services for agent configuration, channels, stateful sessions, and real-time message workflows.
  • >Integrated LLM reasoning pipelines alongside streaming text-to-speech (TTS) and speech-to-text (STT) capabilities inside AI-agent workflows.
  • >Designed scalable backend foundations for orchestrating agents reliably across heterogeneous customer interaction channels.
GoWebSocketsEvent-DrivenLLM IntegrationSTT / TTSRedisREST APIs
STATE_MACHINE // VOICE_AGENTFIG. 02
Raw AudioPCM 16kHzWebSocket Audio StreamFull-Duplex HubStreaming STT EngineVAD & Interim TokensAgent Brain & Tool LoopContext Assembly + Tool CallsLow-Latency TTS Chunking
CHANNELS:Multi-Channel
PIPELINE:Real-Time STT/TTS
CASE_03/E-COMMERCE & LOGISTICS
PRODUCTION DEPLOYMENT

Multi-Carrier Shipping, Inventory & Loyalty Microservice

Scalable e-commerce shipping microservice engineered to improve modularity, maintainability, and fulfillment throughput—unifying carrier integrations, automated shipping operations, stock management, and customer loyalty workflows.

Technical Highlights:
  • >Designed and deployed a scalable shipping microservice, improving modularity, maintainability, and runtime performance across the e-commerce platform.
  • >Integrated third-party carrier services including NaqelAPI to automate live shipment tracking, dynamic rate calculation, and order fulfillment.
  • >Built multi-carrier rate comparison, dynamic shipping rule evaluation, and automated shipping label generation, significantly reducing manual operational overhead.
  • >Implemented stock management and customer loyalty capabilities covering real-time inventory tracking, point accumulation, redemption, and engagement workflows.
GoMicroservicesNaqelAPIPostgreSQLRedisREST APIsDocker
SYS_FLOW // SHIPPING_ENGINEFIG. 03
Order & Checkout EventMulti-Carrier Rules & Rate EngineRate Comparison + Dynamic RulesNaqelAPIRates & TrackingCarrier APIsFallback PoolLabel EngineAuto DispatchInventory & Loyalty Ledger SyncStock Updates · Points · RedemptionsLIVE TRACKING & ORDER FULFILLMENT
CARRIERS:Multi-Carrier
FULFILLMENT:Automated Labels
//SELECTED PROJECTS & GO TOOLING
PACKAGES · CLIS · STREAMING SERVICES
PROJ_01 // CLI TOOLING

Griffin CLI

Go Web Application Development Tool

Built a Go CLI inspired by Phoenix tooling for rapid project scaffolding, CRUD code generation, database migrations, and clean REST API setup using Cobra, Echo, GORM, and Goose.

GoCobraEchoGORMGoose
PROJ_02 // GO PACKAGE

html2pdf

HTML-to-PDF Go Package

Developed a Go wrapper around Rod and pdfcpu for programmatic HTML-to-PDF conversion with an ergonomic, developer-friendly API built for automated document generation.

GoRodpdfcpuPDF Engine
PROJ_03 // STREAMING API

LLM Chat Service

Concurrent Go Streaming Service

Built a lightweight, concurrent Go service for single-conversation LLM chat delivering real-time token streaming directly to clients over Server-Sent Events (SSE).

GoSSELLM StreamingConcurrency
// 04. ENGINEERING PHILOSOPHY

Foundational Principles

8 CONVICTIONS // SWIPE DECK

“Software engineering is fundamentally about understanding constraints, designing principled systems, and delivering end-to-end reliability.”

— Mahmoud Younes, Engineering Notes
CONVICTION 01 / 08
01OF 08

Understand the problem before choosing the technology.

Every architectural tool introduces its own operational tax. Never choose an ecosystem just because it is fashionable; let domain constraints dictate the design.

// 05. TECHNICAL CAPABILITIES

Production Stack & Tools

MATRIX OF PRACTICAL PROFICIENCY
LANGUAGES[4]
  • Go (Golang)PRIMARY
  • JavaScript / TypeScriptPROFICIENT
  • CSYSTEMS
  • SwiftCURIOUS
High daily affinity for Go runtime primitives & concurrency.
BACKEND & INFRA[6]
  • Gin / EchoHTTP ROUTING
  • PostgreSQLRDBMS / MVCC
  • RedisCACHE / PUBSUB
  • Docker & K8sCONTAINERS
  • REST & WebSocketsSTREAMING
  • Server-Sent EventsSSE REALTIME
Engineered for horizontal scale and zero-downtime rolling deploys.
ARCHITECTURE[6]
  • Distributed SystemsPARTITIONING
  • Concurrent ProgrammingSYNC / CHANNELS
  • API Design & ContractsSPECS / JSON
  • Performance TuningPPROF / TRACE
  • Observability & TracingOTEL / LOGS
  • MicroservicesEVENT-DRIVEN
Focus on low allocations, deterministic error states, and clear boundaries.
AI & ORCHESTRATION[6]
  • LLM IntegrationFRONTIER APIS
  • AI Agent OrchestrationSTATE MACHINES
  • Dynamic Tool-CallingSANDBOX EXEC
  • Speech-to-Text (STT)STREAMING
  • Text-to-Speech (TTS)SYNTHESIS
  • AI Developer WorkflowsAGENT CLI
Bridging deterministic systems with frontier model reasoning.
06 // TRANSMISSION· GET IN TOUCH

Have an interesting problem to solve?

I am always interested in exchanging ideas, exploring rigorous technical challenges, discussing distributed systems architecture, and building useful software tools.

DIRECT CHANNELS
ENCRYPTED // TLS
// TRANSMISSION READY