.NET development
APIs and backends in C# — built the way a system that has to survive its third year of changes is built.
.NET is what I reach for when correctness matters more than novelty: a typed language, a mature runtime and tooling that catches problems at compile time rather than in production. I build APIs and services with Clean Architecture and CQRS, EF Core over PostgreSQL, and the discipline that makes a codebase safe for someone else to change.
What's included
REST APIs that are documented
ASP.NET endpoints with OpenAPI, typed responses and consistent error format — a frontend developer can work from the docs without asking you questions.
Clean Architecture and CQRS
Domain logic separated from infrastructure, commands separated from queries. Structure that stays readable as the feature list grows.
EF Core and PostgreSQL
Modelled schema, versioned migrations and queries that don't fall apart once the tables have real row counts.
Predictable error handling
Expected failures returned as results rather than thrown as exceptions, with RFC-compliant problem details on the wire.
Integration tests over real infrastructure
Tests that run against a real PostgreSQL in a container, so they prove the system works instead of proving the mocks agree.
Frontend included if you want it
I also build the React / Next.js side, so there's no gap between backend and UI where responsibility gets lost.
How we'd work
- 01
Scope, in writing
We agree exactly what gets built and what it costs before any code — no creeping invoice, no surprises.
- 02
Ship in slices
Working software every week, not a big-bang reveal at the end. You see progress and can change course early.
- 03
Pay after launch
You pay once the project is live and you're happy with it. No upfront deposit.
Related work
Questions clients ask
Why .NET rather than Node.js?
For business systems with real data rules, static typing and a mature runtime prevent a category of bugs outright. Node is fine for plenty of things — I've written about the trade-off in the journal rather than pretending one always wins.
Can you take over an existing .NET codebase?
Yes. I assess what's there, add tests and observability around the risky parts, then change things safely. Rescue work is a normal part of what I do.
Which .NET version do you use?
Current LTS, on stable releases rather than previews. If you're on something older, upgrading can be part of the scope.
Do you write tests?
Yes, integration tests first, against real infrastructure in containers. In-memory database fakes prove very little, so I don't use them.
Can you work with our existing team?
Yes — with your conventions, your review process and your repository. I write code that reads like the code already there.
Have a project in mind?
Tell me what you're building and where it's stuck. I usually reply within a few hours.