Celery Experts in Germany

Transmission system operator – network provisioning platform (team lead)

• Designed the saga orchestrator in Python that provisions network fabrics with rollback.
• Split IP, identity, and resource allocation into bounded contexts with their own databases and typed clients.
• Implemented data access using DDD repositories and units of work, with no SQL in the domain code.
• Required integration tests using real PostgreSQL and RabbitMQ containers, and API fuzzing for every service.
• Introduced an agent workflow where a spec starts each change and a human approves every merge.
• Rolled out OpenTelemetry auto-instrumentation through GitOps across eighteen Kubernetes clusters.
• Led incident response for stuck provisioning and recorded every outage as a post-mortem.

Languages and software used: Python, FastAPI, Pydantic v2, SQLAlchemy async, PostgreSQL, RabbitMQ, Celery, pytest, testcontainers, schemathesis, Helm, Flux CD, GitLab CI, OpenTelemetry, pi coding agent.

Software product company – datacenter simulation SaaS (backend development)

• Built the asynchronous simulation pipeline as the second-largest contributor among more than twenty team members.
• Tagged every image by commit SHA and semver in the GitHub Actions deployment workflows.
• Diagnosed the RabbitMQ memory alarm that froze every simulation and fixed the limits in the Helm chart.
• Converted the test suite to function-style pytest, with coverage reported in every pipeline.

Languages and software used: Python, FastAPI, SQLAlchemy, Alembic, Celery, RabbitMQ, Redis, PostgreSQL, S3, EKS, Helm, Keycloak, GitHub Actions, pytest, mypy, ruff, SonarQube.

Internal AI platform – model serving and telemetry

• Built the FastAPI service that deploys open-weight models on GPU tiers as OpenAI-compatible endpoints.
• Upgraded production EKS by two Kubernetes minor versions and fixed zone-bound storage faults.
• Traced every model call, including its token count, cost, and latency, through the OpenTelemetry operator.

Languages and software used: Python, FastAPI, vLLM, LangGraph, pydantic-ai, OpenAI and Anthropic APIs, EKS, Helm, Flux CD, Terraform, GitLab CI, OpenTelemetry, Grafana.

• Created complex backend systems (Fastapi Python, GCP cloud functions, APIs, integration tests) using Typescript.
• Worked with firebase and firestore databases, implementing transactional operations, scheduling jobs, and migrations.
• Implemented GCP dashboards for thorough monitoring and custom alerts in case of anomaly traffic.
• Implemented Sentry for better debugging, error tracking and overall monitoring of the Next.js frontend.
• Implemented story tests for UI related testing.
• Implemented Typesense in Python Fastapi backend, for improved text based searching along with typo handlings.

• ▶ Built real-time voice assistant (STT → LLM → TTS pipeline) benchmarking and evaluating multiple STT providers including faster-whisper and Azure Speech. achieved sub-3s latency, Groq API (Llama 3) with multi-turn memory - directly handling edge cases in dictation, names and passcode recognition.

Manufacturing intelligence platform with enterprise workflows, RAG, real-time AI assistant features, and multi-repository backend architecture.

• Built and extended production AI/backend services with Django, DRF, FastAPI, GraphQL, Celery, PostgreSQL, MySQL, Redis, and WebSockets across a modular multi-repository platform.
• Contributed to ARIS V2, a real-time manufacturing AI assistant using LangChain, LangGraph, MCP tool orchestration, planning/execution flows, OpenAI, AWS Bedrock, Qdrant, and Elasticsearch/OpenSearch-backed retrieval.
• Supported rollout expansion from ARIS V1 in 4 of 17 client production plants to ARIS V2 currently active in 13 of 17 plants, increasing real-world deployment coverage to more than 50% of the client footprint.
• Worked on document-grounded RAG functionality including ingestion, OCR, chunking, embeddings, indexing, retrieval, reranking, and grounded answer generation for industrial workflows.

Stack: Python, Django, DRF, FastAPI, LangChain, LangGraph, GraphQL, Celery, WebSockets, OpenAI, AWS Bedrock, Qdrant, Elasticsearch/OpenSearch, PostgreSQL, MySQL, Redis, Docker.

• Expert-supervised AI systems for scientific reasoning, model evaluation, and research workflows.
• Built the IAS Problem Solver, an orchestrated system for difficult mathematical reasoning; it achieved 84% in one submitted answer set on the Leipzig mathematics benchmark.
• Built a resumable state-machine pipeline for research-grade mathematics benchmark generation: source selection, LLM-agent-based phenomenon discovery, task synthesis, gold-answer and certificate generation and validation, probing, repair, human feedback, and quality gates, targeting tasks that are difficult, natural, verifiable, and cost-effective.
• Current work extends this into budget-aware AI research workflows for real scientific problems with expert review.

Tech stack: Python, OpenAI/OpenRouter-compatible APIs, embeddings, RAG, SQLite.

• Developed backend for Audit Management Tool using Node.js/Express with Workday API integration.
• Built secure file handling (PDF, PPT, CSV) with AWS S3 and database support via PostgreSQL, Prisma, and MongoDB.
• Implemented validation, role-based access, and audit trails for compliance and data integrity.

• Delivered AI and data science solutions, including LLM-based chatbots and data pipelines, improving operational efficiency.
• Collaborated on product features, achieving measurable impact and maintaining strong client relationships.

End-to-end responsibility for all products – conception, architecture, development, and production operations as the sole developer; also customer discussions, proposals, and marketing.

Underwriting Copilot – AI assistant for industrial insurance (in production with a customer)

• Supports underwriters in analyzing industrial insurance submissions – in production at an industrial insurer.
• Framework-independent RAG architecture with Hybrid Search (BM25 + pgvector) across large, heterogeneous document collections.
• Two-stage evaluation and observability pipeline (code assertions + LLM-as-Judge) that makes answer quality, retrieval accuracy, and citation integrity measurable in a regression-safe way.

Kaiki Menu Analyzer – Data intelligence platform (in production with a customer)

• Automatically collects and analyzes food data from around 25,000 German restaurants.
• Scalable 7-container architecture (FastAPI, partitioned PostgreSQL, Redis/RQ) with LLM-supported extraction of structured data from PDF, HTML, and images.
• Complete CI/CD pipelines (GitHub Actions), production cloud deployment, interactive dashboards (Dash).

Kaiki GEO Atlas – GEO platform (in production with a customer)

• Measures brand visibility across five AI engines (ChatGPT, Gemini, Perplexity, Grok, Claude), each augmented with web search, orchestrated as a DAG workflow pipeline (Dispatcher → Sub-Workflows → Scoring → Report) with fail isolation.
• 6-container deployment (FastAPI, Celery, Redis, PostgreSQL); LLM cost estimation, PDF audit report, rule-based cross-signal insights (no additional LLM effort).

Data Pipeline & Analytics Platform – Competitive analysis in the automotive aftermarket

• Automated data pipeline with gap analysis algorithms and role-based access control; 230+ tests.
• Backend with FastAPI, PostgreSQL, SQLAlchemy.

Product development (actively in development)

BankingGPT – AI assistant for complaint management in cooperative banking

• Security architecture at its core: no AI draft reaches the customer without human approval – the approval decision is stored in auditable code, not in the language model (monotonic: the model may increase the level, but never lower it).
• Genuine agentic components, each with its own boundaries: the model selects tools itself through an MCP server (read-only, allowlisted, capped, fail-safe); sensitive cases are sent via the open A2A protocol (JSON-RPC, Agent Card, message/send/tasks/get; client implemented independently) to a standalone specialist agent (securities/law), which never lowers the review requirement (pinned by tests).
• Evaluation-driven across ten analysis rounds; an independent review and blind tests uncovered a security defect that nine automated runs had missed.
• Voice AI frontend, responding live: covered cases are answered during the conversation, while sensitive cases are escalated before generation; measured response latency < 7 s (local GPU STT/TTS).

Stack & production readiness: Python, pydantic-ai, FastAPI/Celery, PostgreSQL/pgvector, FastMCP, fasta2a, Docker; multi-tenant (physical vector isolation per tenant), encrypted PII, OWASP-LLM-reviewed, 275 tests, CI/CD; provider-portable (Ollama / EU-Cloud-Vertex).

After-Sales Assistant – agentic RAG/GraphRAG assistant based on public OEM manuals (automotive after-sales)

• Genuinely agentic with LangGraph: ReAct agent with four tools and conversation memory – the model decides itself whether to use the manual (RAG, Chroma), a knowledge graph (GraphRAG, Neo4j/Cypher – decoding warning lights), or a workshop/booking service.
• Human-in-the-loop before the irreversible action: before every appointment booking, the graph pauses (interrupt) and obtains the driver's explicit confirmation – the same approval-before-action discipline as in BankingGPT, in a different framework.
• Eval as a CI gate: three-part scorecard (RAGAS grounding + deterministic tool-routing accuracy + DeepEval safety: does the answer mention the warning first in the case of a critical warning?) blocks the pipeline; provider-agnostic (OpenAI/Azure/Anthropic), FastAPI with token streaming.

Stack: Python, LangChain/LangGraph, Chroma, Neo4j, RAGAS/DeepEval, FastAPI, Docker.

• Developed a multi-agent system connecting LangChain ZeroShotAgent with custom tools for live APIs and task automation.
• Built a FastAPI backend for Jira ticket creation, triage, and assignment, with automatic severity classification, deduplication, SLA setup, on-call rotation, and two-way syncing of status and comments.
• Added Slack alerts and RAG knowledge lookup with FAISS or pgvector to suggest fixes, with optional PagerDuty escalation for policy breaches.
• Orchestrated agents with a router and a Celery plus Redis queue, including retries with backoff, rate limits, idempotency keys, and human-in-the-loop approvals.
• Implemented guardrails and observability, prompt versioning, token and cost budgets, PII redaction, tool-use allowlists, timeouts, OpenTelemetry tracing, accuracy and latency dashboards, and deployment on Kubernetes with feature flags and canary rollouts.

• Engineered production-ready Azure environments using Terraform, ensuring consistent infrastructure parity across VNets and Resource Groups
• Implemented Microsoft Fabric tenant and workspace architecture for multi-stage Medallion data processing pipelines
• Designed secure data pathways using Managed Private Endpoints for isolated Azure Storage access
• Managed Service Principals and authentication tokens for secure REST API integrations

• Freelance Software Engineer with a focus on backend (Python/Django) and frontend (VueJS).

• Implemented a command line interface (CLI) for integration of REST APIs of various microservices for end users
• Centralized and simplified interaction with services through the CLI
• Implemented a REST microservice for custom data schemas based on an API-first approach
• Developed event-driven control with RabbitMQ to connect to other services
• Deployed services using Docker and Kubernetes and extended the CLI
• Managed complexity and data volume handling through the microservice

• Expansion and maintenance of existing custom information systems based on Django
• Technologies used: Django, Django REST Framework, MySQL, Docker