$ kubectl describe principles
Principles
- Architecture before code: I see every project as a whole. Decisions made early secure scalability, security and maintainability.
- Scalability is non-negotiable: Good software must scale. Whether ten or ten thousand users — architecture, deployment and data flows have to be built for it.
- Tests as foundation: "What is not tested does not work." Only with consistent integration tests, realistic scenarios and automated pipelines can software stay stable under load and in production. Happy to work TDD-first: write the test, then the implementation.
- Realism over lab conditions: Dev environments must mirror production — smaller but real. Only then can errors be caught early. And it must always be possible to reproduce production issues locally.
- Automation & consistency: A deployment has to run with one command, a test environment with one click. GitHub or Azure Pipelines orchestrate container dependencies, key vault secrets and build chains — automated, for example via Cake.
- Use AI deliberately: AI can accelerate development tremendously — but an AI feature is only valuable when it is understood, reviewed and cleanly integrated. I use AI as a tool, not as a black box.
- Transparency & knowledge transfer: I do not leave a black box behind. I leave a solution teams understand and can evolve on their own.
An example from my work
On a client engagement, tests had long been run against simplified in-memory databases while production used Postgres. The result: hours spent debugging, endless log reading, because bugs only surfaced in live operation. Some queries behaved very differently locally — primarily because Entity Framework treats in-memory databases very differently from a real one.
My approach: Containerized integration tests with TestContainers. Instead of artificial test databases, every environment — from the developer laptop to the CI/CD pipeline — now runs real instances of the same database as production. TestContainers.
- Realistic tests that surface the same bugs that production would later show.
- No risk to production data, because every instance runs in isolation.
- Less time in debugging, because problems appear early and reproducibly.
What used to be a permanent pain point became a reliable foundation: developers and teams can trust their tests — and nasty production surprises belong to the past.
Why this matters
Above all, my way of working creates one thing for clients: confidence.
- Scalability means: Your system grows with your business — without being reinvented every time.
- Realistic tests means: Bugs are found before they hit you in front of a customer or in production.
- Automation means: Fewer manual errors, faster cycles and more reliable deployments.
- Sustainable AI integration means: New features shipped faster — but in a way your team can understand and operate long-term.
In short: You avoid nasty surprises, save time and cost — and get systems you can actually rely on.