.NET Development

The backend we reach for when the data matters.

.NET is where we put workloads that have to be right: patient records under field-level encryption, mediation case files, tronc payments distributed to hospitality staff, and health platforms operating under clinical scrutiny.

We run current .NET across the estate today, on PostgreSQL and SQL Server alike, with Clean Architecture and CQRS where a domain earns that structure and a straightforward layered API where it does not. The point is a codebase a different team could still reason about in five years.

What we build with .NET

Versioned ASP.NET Core APIs

REST APIs with explicit versioning, OpenAPI documentation via Swagger and Scalar, and generated typed clients for every consumer.

Encryption for regulated data

EF Core field-level encryption backed by Azure Key Vault, protecting patient records in a live clinical system.

Clean Architecture and CQRS

MediatR-based command and query separation with FluentValidation at the boundary, applied where domain complexity justifies it.

Background processing

Hangfire job servers with authenticated dashboards for scheduled and long-running work that must survive a deploy.

Real-time over SignalR

Hubs pushing live events to web and Flutter clients — badges, goals, medication reminders and feature toggles.

Cross-platform desktop and mobile

.NET MAUI where a native client makes more sense than a browser, sharing domain code with the API.

What is actually in our .NET projects

Not a wish list. Every library below is running in a repository we maintain.

Runtime & API

  • .NET
  • ASP.NET Core Web API
  • Asp.Versioning
  • Swagger / Swashbuckle
  • Scalar
  • .NET MAUI

Data

  • Entity Framework Core
  • PostgreSQL / Npgsql
  • SQL Server
  • Azure SQL
  • MongoDB.Driver
  • Redis

Architecture

  • MediatR (CQRS)
  • FluentValidation
  • AutoMapper
  • Polly
  • Hangfire
  • SignalR

Security

  • ASP.NET Core Identity
  • JWT bearer auth
  • Azure Key Vault
  • Field-level encryption
  • BCrypt

Testing & quality

  • xUnit
  • Moq
  • Testcontainers
  • Custom Roslyn analysers
  • Bugsnag

Delivery

  • Docker multi-stage builds
  • EF migration bundles
  • GitHub Actions
  • AWS ECS / ECR
  • Azure App Service

How we work in .NET

Choosing the stack is the easy part. These are the decisions that determine whether the codebase is still maintainable after we hand it over — and they are the same on every .NET project we run.

Our certifications
  • Database migrations ship as EF migration bundles baked into the container image, so the schema and the code that expects it are deployed as one artefact.

  • Integration tests run against a real PostgreSQL instance via Testcontainers rather than an in-memory substitute, because in-memory providers hide exactly the bugs integration tests exist to catch.

  • Custom Roslyn analysers enforce project-specific conventions at compile time, which keeps code review about design rather than style.

  • API clients for web and mobile are generated from the Swagger document, so a contract change surfaces as a failed build in every consumer.

  • Bugsnag across API, web and mobile gives one error timeline per release rather than three unrelated dashboards.

Looking for the service rather than the stack?

.NET is how we build. If you would rather start from what you need delivered, our bespoke software development page covers scope, process and engagement.

Bespoke Software Development

Building on .NET?

Tell us what you are building — or what you have inherited. We will come back with a straight answer on scope and approach.

Get in Touch