Dubai, UAE  ·  Senior Software Engineer

Designing Systems
That Scale Reliably.

Building enterprise-grade backend systems and distributed architectures that perform under real-world load — across healthcare platforms, media streaming, and high-availability infrastructure.

JavaKotlin.NETPostgreSQL RedisAzureKubernetes

Engineering maturity built across industries.

Over the course of my career, I have worked at the intersection of scale and reliability — building backend systems that process millions of events, serve global audiences, and recover gracefully under pressure. My experience spans healthcare and media: two domains where data integrity and uptime aren't aspirational — they're contractual.

At OSN, I contributed to platform infrastructure serving streaming audiences across MENA. At CureMD, I worked on enterprise healthcare software where correctness and compliance were non-negotiable constraints. These aren't environments that reward shortcuts. They reward engineers who think in systems.

I am drawn to problems that live at the boundary of performance and correctness: distributed coordination, event-driven data flows, service boundaries that hold under pressure. I work well in senior engineering teams — contributing architecture decisions, reviewing design tradeoffs, and mentoring engineers who are growing into that same systems-level thinking.

Where I operate with depth.

Distributed Systems

Designing services that coordinate at scale — across process boundaries, network partitions, and eventual consistency constraints. CAP tradeoffs are engineering decisions, not theory.

Backend Engineering

Production Java, Kotlin, and .NET services built for longevity. Clean APIs, disciplined dependency management, testable architectures — code meant to outlast the sprint.

Event-Driven Architecture

Asynchronous pipelines, message brokers, and event sourcing patterns for systems that need to decouple without losing consistency guarantees. Kafka, queues, and beyond.

Cloud Infrastructure

Azure-native deployments with Docker and Kubernetes orchestration. Infrastructure as a product — observable, reproducible, and cost-aware by design.

Performance Optimisation

Profiling hot paths, eliminating contention, restructuring query plans, and tuning caching strategies. Latency is not a detail — it's user experience made measurable.

Database Engineering

PostgreSQL at scale — indexing strategies, partitioning, query optimisation. Redis for caching and coordination. Data models that serve the system, not just the feature.

Problems solved. Outcomes delivered.

Specific details remain confidential. What follows is an accurate representation of the scale and character of the engineering challenges I've engaged with.

Performance

API latency reduction through backend profiling

Problem: A core API serving downstream consumers had accumulated latency under concurrent load, leading to cascading timeouts across dependent services.

Approach: Profiled hot code paths, identified N+1 query patterns, introduced targeted caching at the service layer, and restructured connection pool configuration.

Outcome: Response time reduced by over 60% under peak load. Cascading timeout incidents eliminated. Downstream teams unblocked.

Architecture

Infrastructure cost reduction via architectural simplification

Problem: Over-provisioned infrastructure supporting a legacy synchronous service architecture was generating significant cloud spend without proportional performance benefit.

Approach: Migrated synchronous processing pipelines to event-driven consumers, right-sized Kubernetes workloads, and eliminated redundant inter-service round-trips.

Outcome: Monthly infrastructure spend reduced materially while throughput capacity increased. System became easier to operate and reason about.

Reliability

Multi-tenant onboarding workflow reliability

Problem: A complex onboarding flow involving multiple external integrations had high failure rates at tenant activation, requiring frequent manual intervention.

Approach: Re-architected the flow using a saga pattern with compensating transactions, introduced idempotency at each integration boundary, and added structured retry logic with exponential backoff.

Outcome: Onboarding success rate improved significantly. Manual intervention requirements dropped. Engineering team gained visibility into failure modes for the first time.

Scalability

Database schema and query optimisation at enterprise scale

Problem: A PostgreSQL schema had grown organically, producing degrading query performance as data volume scaled — particularly across multi-table joins with unindexed predicates.

Approach: Audited slow query logs, redesigned index strategy for high-cardinality access patterns, introduced table partitioning, and worked with product teams to rewrite the most expensive query paths.

Outcome: p99 query latency reduced substantially. Reporting workloads decoupled from OLTP paths, improving stability across both surfaces.

Where I have built.

OSN
Dubai, UAE
Media & Streaming

Senior Software Engineer

Contributed to the backend platform powering OSN's streaming product — one of MENA's leading entertainment networks. Worked on content delivery infrastructure, service resilience, and platform reliability initiatives serving millions of subscribers. Operated at the intersection of high-throughput data pipelines and strict availability requirements.

  • Java
  • Kotlin
  • Azure
  • Kubernetes
  • Redis
  • PostgreSQL
CureMD
Enterprise Healthcare
Healthcare SaaS

Software Engineer

Developed and maintained backend systems for CureMD's enterprise healthcare platform — a complex multi-tenant environment serving clinical operations, billing workflows, and patient data management. Navigated compliance constraints and data integrity requirements that demanded precision in every design decision.

  • .NET
  • C#
  • SQL Server
  • PostgreSQL
  • Azure
  • Docker

How I think about the craft.

Reliability over cleverness.

The system that works predictably at 3 AM is worth more than the elegant one that surprises you.

Latency is user experience.

Every millisecond is a design decision. Performance isn't an afterthought — it's a feature shipped at the architecture stage.

Simple systems scale better.

Complexity compounds. Every abstraction has a maintenance cost. The right abstraction is the one you can still reason about under pressure.

Observability is not optional.

You cannot debug what you cannot see. Instrumentation is part of the feature, not a luxury added after production incidents.

Failure is a first-class concern.

Systems will fail. Engineering maturity is designing for that reality — graceful degradation, clear recovery paths, and no silent failures.

Code is read more than written.

Clarity is a form of respect — for the engineer who inherits this system, and for the problem it solves.

Let's talk engineering.

I'm open to senior engineering roles, distributed systems challenges, and engineering leadership conversations. Based in Dubai. Available for remote and on-site roles globally.