Backend-Focused .NET Engineer
Clean Architecture · Explicit Domain Modeling · Deterministic Systems

📍 Hamburg, Germany

In pain we grow, in joy we recognize what already is.

I’m a backend-focused .NET engineer with a strong interest in clean architecture and explicit system design.

My background in game development shaped how I think about invariants, performance, and deterministic behavior.
Today, I focus on building maintainable backend systems with clear boundaries, explicit error handling, and testable domain logic.

A deliberately structured .NET 10 backend application focused on architectural clarity, explicit domain modeling and disciplined layering.

The goal is not feature quantity, but architectural understanding through hands-on implementation.

• Strict layered architecture (Domain / Application / Infrastructure / API / Web)
• Ubiquitous language reflected in use-case structure
• Explicit domain workflow rules
• Result-pattern based error handling (no exceptions in Application layer)
• RFC 9457 ProblemDetails strategy
• Strongly-typed IDs
• Deterministic paging & sorting (CreatedAt + Id tie-breaker)
• Explicit UnitOfWork commit boundary
• EF Core (SQLite) + InMemory provider switch
• End-to-End tests with provider matrix

An experimental Blazor application focused on explicit state management using a reduced Redux-inspired pattern.

The YouTube playlist functionality serves primarily as a domain to exercise architectural patterns — not as the product focus.

Core concepts:

• Centralized Store with explicit state transitions
• Unidirectional data flow
• Action → Reducer → State pipeline
• Immutable state updates
• Snapshot-based undo/redo
• Effect isolation (side effects separated from reducers)
• Deterministic state transitions
• Component dispatch-only architecture

The project explores predictable UI behavior through strict state ownership and separation of concerns.

The architecture intentionally minimizes implicit component state to enforce explicit and traceable application behavior.

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

These projects focus on explicit state modeling, deterministic simulation and clear separation of responsibilities.

A physics-driven N-body gravitational simulation.

• GameMode used as composition root
• Explicit CelestialBody registry for state coordination
• Interface + component-based debug visualization
• Virtual body abstraction for orbit debugging

• Real mass–velocity–distance interaction (no predefined or scripted orbits)
• Fixed time-step integration model
• Documented physical scaling model (AU, mass ratios, velocity calculations)

Extensive technical documentation included.

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

• Explicit resource and state handling
• Camera system (pan, rotate, zoom)
• Wireframe rendering mode

• Assimp-based model import
• OpenGL rendering pipeline
• Shader-based lighting (ambient / diffuse / specular)

Built with GLFW, GLAD and modern OpenGL.

I value clarity, ownership and intentional system design.

For me, engineering means making decisions explicit — in code, in architecture and in collaboration.

• Boundaries are deliberate, not accidental
• Domain logic is expressed, not hidden
• Trade-offs are discussed explicitly
• Quality is a responsibility, not an afterthought

Open to backend-oriented engineering roles in Hamburg that value architectural clarity and thoughtful collaboration.