Mohsin Kokab
  • Open to senior roles
  • Berlin, Germany
  • Remote-ready worldwide

Over a decade of production backend.Now I ship it with AI agents doing the work, and gates catching what they get wrong.

I'm Mohsin Kokab. I've kept regulatory platforms running at 99.99% for DAX40 clients, moved monoliths onto Kubernetes, and led the teams that did it. Today I build with agentic engineering: loop and graph orchestration with verification gates. That is what makes the speed repeatable instead of lucky.

  • Permanent residence (Niederlassungserlaubnis)
  • English-working
  • Available immediately
  • Open across Germany, remote worldwide

Measured

Voice round-trip latency
Typical cascaded STT → LLM → TTS pipeline~1.5–3 s
Nexus, bidirectional streaming~<500 ms

down 78%

Baseline is an industry-typical range for cascaded pipelines, not an earlier version of Nexus.

Industry baseline, approximate. The Nexus figure is measured.

Evidence

Measured outcomes

Every bar below is a claim with a derivation behind it: what was measured, against which baseline, and where that baseline came from.

Annual downtime budget
Legacy platform, 98%7.3 days / year
After migration, 99.99%52 min / year

down 99%

Regulatory disclosure platforms, DAX40 clients. EQS, 2017–2024.

Time to complete a release
Manual release process
Automated GitLab CI/CD

5× faster

Manual transfers → fully automated pipeline, enabling daily releases. EQS.

Post-deploy issues, normalised to a monthly rate
Monolith, manual gates~2–3 / week
After migration~1 / month

down 91%

EQS. Weekly figure converted to monthly so both bars share a unit.

Source figures are stated as ranges ("2–3/week", "~1/month").

Infrastructure spend, indexed to pre-migration baseline
Before migration100
After AWS EKS migration75

down 25%

Indexed, not absolute. EQS cloud migration.

Time to configure a new voice agent, indexed
Hand-configured100
Dynamic prompting10

down 90%

Indexed, not absolute. Nexus, 2025.

For scale

Business Impact

  • DAX40+Enterprises Served, Daily Operations

Speed & Efficiency

  • 70%Time Savings, Automation

Leadership & Impact

  • 6Avg Team Size, Led Cross-Functional
  • 3Agile Transformations, Led & Coached

Method

How I build

An agent that writes code is not the interesting part. What changes the outcome is where the check sits: put a machine-checkable acceptance condition in front of the generation instead of behind it, and every attempt gets graded without a human in the way. Nothing here makes the generator more accurate. It makes being wrong survivable.

How I build: the build loop as a directed graphA directed graph of five steps. Spec feeds Failing test, which feeds Generate, which feeds Verify. Verify is a gate with two exits: work where every check is green leaves the loop, and work where any check is red goes to Repair. Repair has two return edges: back to Generate when the code was wrong, and back to Spec when the acceptance condition itself was wrong.passesfailsfailure as contextSpecFailing testGenerateVerifyRepair

Verify is the only exit. Everything else re-enters the loop: at Generate when the code was wrong, at Spec when the criterion was.

Spec
The work is written down before it is written: what has to change, which files and interfaces it touches, what is explicitly out of scope, and what would count as proof. It is not dictated but interrogated, and that is the point at which a vague request stops being vague.
Failing test
Each acceptance condition becomes a check that fails first, and fails for the stated reason. It has to come before the code, because a check written afterwards tends to describe what was built rather than what was wanted.
Generate
Only now is code written, and only as much as it takes to turn that one check green. Reading that would otherwise fill the context window is pushed out to subagents that hand back a summary rather than a transcript, because accuracy falls as the window fills and a bloated prompt is not a free upgrade.
Verify / gate
The gate, in two tiers: the deterministic checks first, then an adversarial review by a subagent in a fresh context, given the diff and the acceptance conditions but not the reasoning that produced them. The second tier finds what the first cannot express, and it never overrules a red result from the first.
Repair
A failed check comes back carrying its own evidence, and that evidence is the next attempt’s context rather than a fresh guess. The loop is bounded on purpose: a failure that survives repeated attempts is escalated instead of ground at.
  • Verify → leaves the loopevery check green, with the evidence attached
  • Verify → Repairany check red
  • Repair → Generatethe failing output becomes the next attempt’s context
  • Repair → Specwhen what was wrong is the acceptance condition, not the code

The leverage is upstream: agentic engineering in 2026the six stages around this loop, the published research the gate design rests on, and the randomised trial that argues against all of it

Work

Selected work

Each one opens as far as it honestly can: some into a write-up, some into the running thing.

  • 1:28

    First Light

    Watches every automation you run and turns the night's failures into a morning brief: what broke, why, and the next step for each. Failures are grouped by root cause, and the dead-letter queue replays without double-processing.

    A replay checks the item key before it re-executes, so it will not double-send an invoice to make a dashboard green.

    TypeScriptNext.jsHonoDrizzlePGlite
  • 2:36

    Switchyard

    An operations console for voice-AI phone agents: every call the agent took, every question it could not answer, and every write-back to the CRM shown as verified by a read-back rather than assumed from a 200.

    A write-back counts as verified only once a read-back confirms it. A 200 is a claim; the read-back is the proof.

    TypeScriptNext.jsHonoDrizzlePGlite
  • 1:00

    MockGen

    Turns a plain-English requirement into a live, stateful REST or GraphQL mock server.

    Built in two days, and the whole history is public, so the timeline is auditable rather than asserted.

    PythonFastAPIVue 3PydanticOpenAI/Gemini
  • Regulatory disclosure platform

    Six years on a DAX40 regulatory disclosure system, monolith to cloud-native.

    Regulated finance: the migration had to land without a disclosure window closing.

    JavaSpring BootDockerKubernetesAWS EKS
  • Job-hunt automation

    LLM orchestration over a job pipeline: parse, score for relevance, draft, track.

    The interesting part is not the drafting. It is keeping a hundred concurrent flows recoverable.

    PythonFlaskLangChainReactSQLAlchemy

Also built

  • Nexus Voice AIreal-time voice agent platform, bidirectional streaming2025
  • Isometric Game Design SDKiOS SDK for isometric game environments2013
  • Scanner In Your HandAndroid document scanner with perspective correction2012

Experience

Every role, drawn to scale

6 roles since 2011: high-availability regulatory platforms for DAX 40 issuers, a cloud migration that cut infrastructure spend 25%, and production voice AI since 2025. The bars are the real date ranges, so the founder-and-lecturer years overlap the employed ones.

14 yr 5 moof engineering, first role to today. Overlapping roles counted once.

Senior AI & Backend Engineer

Independent ConsultantJan 2025 - Present · 1 yr 7 moBerlin, Germany

Went independent to build production voice AI and agentic systems end-to-end: architecture, streaming infrastructure, and the tooling around them. Now looking for a team to do this at scale.

What I did

  • Take product requirements to production through a specification-first process: adversarial clarification sessions that close every open question before code exists, a technical design with the decisions recorded, then milestones marked for which can run in parallel by change-set overlap.
  • Deliver each milestone behind a two-tier verification gate: deterministic checks first (types, build, test suite), then an independent review in a fresh context that never overrules a deterministic failure. Tests are written before the code that satisfies them, and mutation checks run on the paths where being wrong is expensive.
  • Architected 'Nexus', a production Voice AI Platform delivering sub-500ms latency via Gemini 2.5 Live API and bidirectional WebSocket streaming.
  • Engineered a secure hybrid Node.js/React infrastructure featuring Function Calling to visualize AI reasoning states in real-time.
  • Developed multi-agent automation pipelines (n8n, Make.com) and open-source tooling (MockGen) that cut manual steps out of developer workflows.

Stack

  • Claude Code
  • Google Gemini 2.5
  • WebSockets
  • React
  • Node.js
  • Python
  • LangChain
  • n8n

Full timeline, including education and certifications

Stack

What I work with

Grouped by domain. The year counts are time spent shipping with the tool in production, not exposure to it. Where a count would mislead, it is left off rather than guessed.

Agentic Engineering

  • Claude Code1.5+ yr
  • Loop & Graph Orch.1.5+ yr
  • Verification Gates1.5+ yr
  • Spec-Driven Dev.1.5+ yr
  • Subagent Orch.
  • TDD as Agent Gate

Core & Languages

  • Java12+ yr
  • Python5+ yr
  • Groovy5+ yr
  • C++6+ yr
  • C#3+ yr
  • TypeScript4+ yr
  • SQL10+ yr
  • Hexagonal Arch.6+ yr
  • Microservices7+ yr

GenAI & LLM

  • OpenAI API2+ yr
  • LangChain1.5+ yr
  • crewAI1+ yr
  • Hugging Face1+ yr
  • Gradio1+ yr
  • Prompt Eng.2+ yr
  • RAG Systems1.5+ yr
  • AI Agents1.5+ yr

Cloud & DevOps

  • AWS6+ yr
  • Kubernetes6+ yr
  • Docker7+ yr
  • Terraform4+ yr
  • GitLab CI6+ yr
  • Helm5+ yr
  • Jenkins5+ yr
  • EKS5+ yr

Stack & Tools

  • Spring Boot8+ yr
  • FastAPI3+ yr
  • React4+ yr
  • Next.js2+ yr
  • Hibernate8+ yr
  • Android6+ yr
  • iOS4+ yr
  • Qt3+ yr
  • Unity3D2+ yr
  • Cocos2d-x4+ yr

Decision matrix

What I picked, and what it cost

Every tool here won over an alternative. These are the trade-offs I accepted and the systems they shipped in.

7 of 7 technologies

Technologies I use, why and when I reach for each, the trade-offs accepted, and the system it shipped in.
TechnologyWhy & whenTrade-offsShipped in
FastAPIBackendHigh-perf async Python APIsSmaller ecosystem than DjangoMockGen
Spring BootBackendEnterprise microservicesHeavy startup, verbose configRegulatory Platform
LangChainAILLM OrchestrationFast breaking changesJob Automation
KubernetesCloudScale & Multi-tenancyHigh complexityRegulatory Platform
ReactFrontendInteractive UIsState complexityPortfolio
PostgreSQLDatabaseReliable relational dataVertical scaling limitsRegulatory Platform
GitLab CIDevOpsCompliance-as-code pipelinesVendor lock-inRegulatory Platform

Patterns

What I reach for, and when I don't

Every pattern here has a cost. These are the conditions under which I think it is worth paying, and the ones under which it is not.

In production

  • Microservices

    Decomposing monoliths by domain

    Use when
    Independent scaling needs
    Avoid when
    Small teams/projects

    See the implementation

  • Event-Driven

    Async communication via broker

    Use when
    Decoupling services
    Avoid when
    Sync response needed

    See the implementation

  • Blue-Green Deploy

    Zero downtime traffic switch

    Use when
    High availability
    Avoid when
    Limited infra budget

    See the implementation

  • RAG

    Context injection for LLMs

    Use when
    Private data knowledge
    Avoid when
    Static public info

    See the implementation

Architecture decisions

  • Strangler Fig

    Problem
    Monolith downtime
    Shape
    Legacy -> Proxy -> New Service
    Solution
    Incremental migration via proxy
    Where
    Regulatory Platform Migration
  • RAG + Validators

    Problem
    LLM Hallucinations
    Shape
    VectorDB -> LLM -> Pydantic
    Solution
    Context + Schema Validation
    Where
    Job Automation

Verified LinkedIn recommendations

Trusted by engineering leaders

What a director of engineering, a senior developer and a security leader have written about working with me.

  • Osman Durrani

    Director of Engineering, Financial Compliance Platform

    Leading Enterprise SaaS Provider

    Mohsin consistently demonstrated exceptional adaptability and technical prowess, quickly mastering complex domain knowledge... his dedication to fostering a collaborative environment was truly commendable.

    Verified recommendation

    Read on LinkedIn
  • Joachim Nenning

    Senior Web-Entwickler (15+ yrs Experience)

    Leading Enterprise SaaS Provider

    He worked with me in many complex projects from planning phase , architecture, implementation to delivery... he has a deep understanding in Object Oriented Programming, database design and Dockerization.

    Verified recommendation

    Read on LinkedIn
  • Ahsan Ziaullah

    Security Leader

    AWS Professional Services

    He has a gift for breaking down technical concepts into understandable language... I wholeheartedly recommend him for any leadership role in software engineering.

    Verified recommendation

    Read on LinkedIn

Contact

Open to senior backend and AI engineering roles

Full-time, in Berlin, across Germany, or remote. Email is the fastest route: I reply within 2 business days.

Direct

Every message gets a reply within 2 business days.

Or send a message

Goes to the same inbox as the address above.

If a call is easier

Twenty minutes, if you’d rather talk than write. Same for a first interview.

Needs widget cookies

The calendar is embedded from Cal.com, which sets its own cookies. Allow scheduling widgets to load it here, or open it directly instead.