Backend-Focused .NET Engineer
Clean Architecture · Reliable Processing · Explicit Domain Logic

📍 Hamburg, Germany

I'm a backend-focused .NET engineer who came into software through game development.

Studying game programming taught me to care about state consistency, explicit system behavior, and performance under constraints. Those concerns turned out to matter just as much in backend systems. After two years of professional .NET work, growing from junior to mid-level with ownership of three projects, I now focus on systems that stay understandable and changeable over time. Based in Hamburg, open to hybrid roles.

Two backend projects that highlight complementary engineering concerns:
Ingestor focuses on reliability, fault handling and operational resilience.
ServiceDeskLite focuses on architecture, domain boundaries and design clarity.

A reliable import system for processing delivery data from multiple suppliers. Built for a fictional furnishing logistics company (Fleetholm Logistics).

The goal is not domain complexity, but technical reliability — retry logic, dead-letter handling, idempotent processing and full audit trails. Extended with a Blazor Server web UI and deployed to Azure Container Apps via an automated CI/CD pipeline.

• Two-process architecture (API Host + Worker Host)
• Database-backed job orchestration (Outbox pattern)
• Configurable dispatcher abstraction (DB queue or RabbitMQ, config-switch)
• Message-driven processing via RabbitMQ with dead-letter exchange
• Automatic retries with exponential backoff
• Dead-letter handling with manual requeue
• Idempotent file ingestion (content hash + supplier)
• Explicit status model with strict state transitions
• Structured error classification (transient vs. permanent)
• Batch import with chunk processing and partial success handling
• Full audit trail for every job lifecycle event
• OpenTelemetry tracing and structured logging
• Integration tests with Testcontainers
• Blazor Server web UI (Dashboard, Imports, Dead Letters)
• Deployed to Azure Container Apps with Azure Blob Storage for key persistence
• Automated CD pipeline: GitHub Actions builds, pushes to Azure Container Registry, and deploys on every merge to main
• Passwordless Azure authentication via OIDC (Workload Identity Federation)

Repository: https://github.com/goldbarth/Ingestor

A deliberately structured .NET 10 backend application demonstrating clean layering, explicit domain rules and consistent error handling in a realistic setup.

The goal is not feature breadth, but structural clarity, explicit boundaries, and reviewable design decisions.

• Strict layered architecture (Domain / Application / Infrastructure / API / Web)
• Explicit domain workflow rules
• Result-based error handling (no exceptions crossing application boundaries)
• RFC 9457 ProblemDetails strategy
• Strongly-typed IDs
• Deterministic paging & sorting (CreatedAt + Id tie-breaker)
• Explicit UnitOfWork commit boundary
• EF Core (PostgreSQL) + InMemory provider switch
• End-to-end tests with provider matrix

Repository: https://github.com/goldbarth/ServiceDeskLite
Documentation: https://goldbarth.github.io/ServiceDeskLite

Beyond backend architecture, I have built system-oriented projects in C++ and Unreal Engine.

These projects shaped how I approach backend systems today:
explicit state handling, clear ownership and predictable behavior.

A physics-driven N-body simulation with fixed time-step integration.

• GameMode as composition root
• Explicit CelestialBody registry
• Separation between simulation logic and visualization
• Real mass–velocity–distance interaction

Repository: https://github.com/goldbarth/SolarSystem

A minimal rendering engine capable of loading and displaying OBJ models.

• Explicit resource and state handling
• Camera system (pan, rotate, zoom)
• Shader-based lighting

Repository: https://github.com/goldbarth/3DModelViewer

Open to backend-oriented engineering roles in Hamburg.