Vienna, Austria
Mehdi Bayat
Senior Full-Stack Engineer · Distributed Systems · Cloud & AI
I build real-time, scalable software and use AI to accelerate engineering without outsourcing engineering judgment.
Featured Engineering
LivePulse
Real-Time Sports Intelligence Platform
A continuously running, event-driven sports data platform built on real football/soccer data — not a simulator. LivePulse ingests live match data from a real external provider (API-Football), detects meaningful changes, publishes internal domain events, and pushes real-time updates to the browser over WebSockets, backed by PostgreSQL for durable history, Redis for live state, and Kafka as the internal event backbone.
Status
Live and running against real data, not a local-only demo: ingestion, change detection, Kafka, WebSockets, observability, and automated testing are all built and verified against real API-Football and football-data.org data. An AI-features phase is deliberately deferred and kept separate from the core pipeline.
Featured Engineering
AgentForge
Governed Autonomous Software Engineering Platform
A LangGraph-orchestrated multi-agent system (Planner, Architect, Researcher, Developer, Reviewer, QA, Security) where no agent's approval is the final word. A deterministic verification gate (real type-checking, linting, test execution, static security scanning) and a risk-based human-approval policy engine decide what actually merges, proven with failure-injection demos where a real failing test overrides a simulated Reviewer approval.
Core principle
LLMs propose and reason. Deterministic systems verify. No agent's approval, including the Reviewer's, is the final word. A real test failure or a real detected secret overrides a simulated approval every time, proven with failure-injection demos, not just asserted.
The live demo runs against a real Postgres/Redis stack with no LLM key configured, so the dashboard, agent registry, and deterministic verification/policy logic are all real and live; starting a full agent run honestly reports "Integration unavailable" rather than fake one.
Featured Engineering
LiveOps
Real-Time Event Processing & Workflow Platform
A modular-monolith event-driven platform: idempotent ingest, a transactional outbox, a workflow engine running real sagas with orchestrated compensation, CQRS projections, real distributed tracing, circuit breakers, and per-visitor sandbox tenants — plus a complete second event-bus transport (Kafka) built and load-tested against the first, an investigation that surfaced three real bugs including one in the load-testing tool itself.
Status
Both planned phases complete and verified against a real running stack, not asserted: the live process was killed mid-batch, mid-workflow, and pre-dispatch to prove crash recovery; a real saga was forced through full backward compensation; two separate load tests found and fixed four production-shaped bottlenecks across two different event-bus transports — including a bug in the load-testing tool itself, found while trying to explain a number that didn't add up.
One Engineering Story
Build → Understand → Validate
BUILD
LivePulse
The real distributed system: event-driven ingestion, Kafka, Redis, PostgreSQL, and a WebSocket gateway pushing live updates to the browser.
UNDERSTAND
Architecture Lab
An interactive companion exploring the system component-by-component: real event flows, 8 accepted ADRs, and the actual production incident, not a marketing diagram.
VALIDATE
Scaling Demo
A real load test against two unmodified LivePulse backend processes, measuring whether the WebSocket fan-out design actually holds up across instances.
One coherent engineering case study — build the system, explain the architecture, and measure the claims.
Recruiter View
Engineering Evidence
Instead of a skills list, here is what each capability is actually backed by.
| Capability | Evidence |
|---|---|
| Distributed systems | LivePulse's event-driven ingestion → change detection → Kafka pipeline; LiveOps's transactional outbox and a second event-bus transport (Kafka) built and measured against the first |
| Workflow orchestration & sagas | LiveOps's WorkflowEngine — a real multi-step saga with orchestrated compensation, verified to roll back in exact reverse order via a forced permanent step failure |
| Real-time systems | WebSocket gateway architecture, validated by the Scaling Demo's real fan-out measurements; LiveOps's live SSE dashboard |
| Messaging | Kafka topics and consumer groups (LivePulse), RabbitMQ event bus (Sportradar), LiveOps's own Postgres and Kafka event-bus implementations behind one interface, swapped with an environment variable |
| Distributed state | Redis cache-aside and pub/sub design with documented failure modes (ADR-004) |
| Reliability | A real production incident investigated and fixed — the WebSocket subscribe race; LiveOps's crash-resume tests (killed the live process mid-batch, mid-workflow, and pre-dispatch), circuit breakers, and dead-letter replay verified on real historic data |
| Observability | LiveOps: real OpenTelemetry tracing linking every async boundary into one trace (verified as a 22-span Jaeger trace) and live Prometheus metrics under real traffic |
| Performance engineering | LiveOps's load tests found and fixed four real bottlenecks across two transports — including a bug in the load-testing tool itself that had been quietly inflating every prior number |
| Architecture | 8 accepted ADRs plus the interactive Architecture Lab exploring them; 13 ADRs on LiveOps |
| Testing | Unit, integration, and Playwright E2E tests across LivePulse and TalentMatch, wired into CI |
| Scalability | Scaling Demo — measured, not assumed, fan-out results across two real instances |
| Cloud | AWS ECS/Fargate, DynamoDB, SQS/SNS, Cognito, CDK/Terraform used in production at Sportradar and in TalentMatch's deployment config |
| AI Engineering | Team-built production RAG pipeline on AWS Bedrock for a Sportradar project (emBET); AI-assisted implementation workflow across personal projects |
| Agentic AI systems | AgentForge: a LangGraph multi-agent pipeline gated by a deterministic verification/policy engine, not by LLM judgment alone |
Also Built
Other Projects
TalentMatch
Production-oriented job matching backend
A modular-monolith backend for publishing jobs and matching candidates: a synchronous Fastify API plus an asynchronous BullMQ worker, with MongoDB as the source of truth, OpenSearch as a rebuildable read model, deterministic candidate scoring, idempotent applications, and a full AWS ECS/Fargate deployment configuration.
AgentForge
Governed Autonomous Software Engineering Platform
A LangGraph-orchestrated multi-agent system (Planner, Architect, Researcher, Developer, Reviewer, QA, Security) where no agent's approval is the final word. A deterministic verification gate (real type-checking, linting, test execution, static security scanning) and a risk-based human-approval policy engine decide what actually merges, proven with failure-injection demos where a real failing test overrides a simulated Reviewer approval.
Architecture Lab
Interactive exploration of the LivePulse architecture
A companion Next.js app that walks through LivePulse component-by-component: the real event flows, the 8 accepted ADRs, the real production incident, and measured-vs-projected scaling — built to make the reasoning behind LivePulse inspectable, not just the code.
Scaling Demo
A real load test for one specific architectural claim
A standalone tool that runs two real, unmodified LivePulse backend processes against shared Redis and measures whether the WebSocket gateway's fan-out design actually delivers updates across both instances — closing a gap LivePulse's own engineering review named honestly.
Technology
Working Stack
Languages
Frontend
Backend
Distributed Systems
Cloud & Infrastructure
Data
AI Engineering
Testing & Quality
Observability
How I Engineer
Engineering Philosophy
- Evidence over assumptions
- Architecture proportional to requirements
- Explicit trade-offs
- Automated verification
- Failure-mode thinking
- Observable systems
- Measured performance, not claimed performance
- Human-owned engineering decisions
AI-Augmented Engineering
Where AI fits in how I build
AI tools are part of my day-to-day workflow — implementation acceleration, test generation, refactoring support, code review assistance, debugging, and documentation. LivePulse and its Architecture Lab were built with heavy AI-assisted implementation, which is exactly why both projects document their engineering process, ADRs, and real incidents so openly: the reasoning has to survive scrutiny independent of who typed the code.
AI accelerates implementation; engineering judgment — what to build, which trade-offs to accept, how to verify a claim — remains human-owned.
Get in Touch