FIXED SCOPEone-off build
Ship a .NET product, end-to-end.
A defined product, a fixed price, a senior-only team. From RFC to launch in 8–14 weeks.
$15k–$30k
FIXED SCOPE
- Senior engineers only
- Fixed quote in week 1
- Code, infra, runbook — yours
.NET backendsthat don'tbecome aliability at scale.
We don't scaffold and hand off. Eleven years of .NET in production — architecture that holds when the team doubles, EF Core that doesn't leak under load, background jobs that don't silently fail at 2am. The decisions most .NET projects skip in year one and regret in year three.
- Vertical slice
- Sub-100ms p99
- Typed end-to-end
- Zero-downtime deploys
Why Entalogics for .NET
Four things every
.NET app
actually needs.
Most .NET codebases we inherit have the same three problems — a DbContext that knows too much, controllers that do too much, and background jobs nobody monitors until the queue is full. We fix the architecture before it becomes the reason your roadmap stalls.
Performance01
Sub-100ms p99, by construction.
AsNoTracking on every read path, output caching at the right layer, connection pooling configured from day one. .NET 8 is one of the fastest server runtimes available — most teams give that back with N+1 queries nobody notices until traffic doubles and the DBA calls.
Architecture02
Vertical slices, not a layered monolith.
One folder per feature. Handler, validator, and tests live together — not scattered across six horizontal layers. A new engineer can find the code for any feature in under thirty seconds. A new endpoint doesn't require touching files from three different folders.
State03
Persistence chosen deliberately, not by default.
EF Core where the domain is complex and migrations matter. Dapper where read performance is measurable and EF's overhead isn't justified. Redis for distributed cache and session. Each decision made per use case — not carried over from the last project.
Type safety04
C# strong types, all the way down.
Value objects over primitive obsession. Result types over thrown exceptions on expected paths. FluentValidation at every entry point. When a domain type changes, the compiler finds every callsite before the code review does.
When .NET, when not
.NET is a tool.
Not a religion.
.NET is a serious framework with a real learning curve and a long tail of operational decisions. We'll tell you on the first call if it's the right fit — or if a lighter runtime solves your problem for half the cost.
PICK .NET WHEN
- The domain is complex — finance, healthcare, logistics — and correctness is non-negotiable
- You have a large team that needs the compiler and the framework enforcing boundaries, not just conventions
- Long-lived codebase with serious refactoring requirements over multiple years
- Existing .NET infrastructure, Windows integration, or Active Directory is already in the picture
CONSIDER OTHERS WHEN
- Lightweight read-heavy APIs where Go or Node.js startup time and memory footprint actually matter
- A small team prototyping fast where deployment simplicity beats type safety right now
- Your engineers already ship another stack well — don't break what's working
WE SAY NO WHEN
- "We want .NET because the enterprise uses it." That's a procurement decision dressed as an architecture one.
- "Just put a .NET wrapper around our stored procedures." We'll tell you honestly if there's a better path.
- "We need this live in three weeks and the schema changes daily." That ship has sailed.
What we build with .NET
Six product surfaces.
One quality bar.
The shapes of .NET work we take on most often. Backend-heavy, enterprise-grade, and built to still be maintainable when the team doubles.
- S01
SaaS API backends
SaaS API backendsMinimal APIs, versioned endpoints, FluentValidation at every boundary, structured logging, OpenAPI docs that stay accurate because they're generated — not maintained by hand.
ASP.NET COREMEDIATRFLUENTVALIDATIONEF CORE - S02
Enterprise web applications
Enterprise web applicationsBlazor for complex internal UIs — multi-tenant data isolation, role-aware navigation, audit logging baked in, WCAG compliance from the first sprint not the last.
BLAZOREF COREIDENTITYSQL SERVER - S03
Background processing & messaging
Background processing & messagingHangfire for scheduled jobs with a real dashboard, MassTransit for event-driven messaging, outbox pattern so no message is lost when a service restarts mid-processing.
HANGFIREMASSTRANSITRABBITMQAZURE SERVICE BUS - S04
Microservices & distributed systems
Microservices & distributed systemsgRPC for typed internal service contracts, YARP for API gateway routing, OpenTelemetry so you know exactly where a slow request spent its time.
GRPCYARPOCELOTOPENTELEMETRY - S05
Internal tooling
Internal toolingReplace the spreadsheet. Replace the five spreadsheets. Replace the Access database three departments depend on but nobody will admit exists.
ASP.NET COREEF COREBLAZORTAILWIND - S06
Legacy .NET migrations
Legacy .NET migrations.NET Framework to .NET 8, Web Forms to Blazor, WCF to gRPC. One endpoint at a time — the current system keeps running while we migrate underneath it.
NET UPGRADE ASSISTANT.NET 8GRPCEF CORE
The playbook
Patterns we
ship on repeat.
The backend patterns that show up on almost every .NET engagement. Proven under real production load — not lifted from a conference talk.
P01
Vertical slice architecture
One folder per feature. Command, handler, validator, and tests live together. No horizontal layers that require touching six files to ship one endpoint. New features don't disturb old ones.
P02
Typed contracts
FluentValidation at the API boundary, value objects for domain primitives, Result types for expected failure paths. The contract is wrong before the PR is open — not after a user reports it.
P03
Cache-first data
AsNoTracking on all read paths. Redis with a consistent invalidation strategy. Output caching for stable responses. The database only does work that actually needs the database.
P04
Domain events
MediatR for in-process events, MassTransit with the outbox pattern for out-of-process messaging. Side effects that are guaranteed to run — and guaranteed not to run twice on a retry.
P05
Integration tests against real infrastructure
xUnit with Testcontainers — tests run against a real database, a real message broker, a real Redis. No mocked infrastructure that behaves differently from production at 3am.
P06
Strangler-fig migrations
YARP reverse proxy in front of both the legacy and new application. Traffic shifts one endpoint at a time. The old system keeps serving until the new one has earned the route.
Signature case
A logistics platform,
brought back from the edge..
A B2B logistics platform on .NET Framework 4.7 — 840ms average API response, controllers averaging 2,400 lines, a single EF6 DbContext with 340 tables, and a deployment process that took the application offline for every release. Migrated to .NET 8 vertical slice architecture in 12 weeks. No feature freeze. No downtime.
Before
p99 API 840ms · avg controller 2,400 lines · EF6 single DbContext · app offline per deploy
After
p99 API 94ms · avg handler 80 lines · EF Core bounded contexts · zero-downtime rolling deploy
- p99 API improvement−89%
- Average handler size−97%
- To fully migrated12wk
- Shipped regressions0
Engagement shape
Eight to ten weeks
to a measurable ship.
A typical .NET engagement runs endpoint by endpoint. The legacy system keeps serving traffic the entire time — we don't ask for a maintenance window to migrate your backend.
- W01
Audit + RFC
Two senior engineers in the codebase. API response profiling, EF Core query analysis, controller complexity inventory, background job failure audit. You leave week one with a ranked RFC and a clear picture of where the risk actually lives.
- W02–03
Foundation + first slice
.NET 8 baseline, vertical slice architecture established, FluentValidation and MediatR wired in, one production endpoint live. Real p99 numbers in your dashboards — not a local benchmark on a fast machine.
- W04–08
Migrate by endpoint, not flag-day
Endpoint by endpoint behind YARP. Legacy and new run side-by-side. Kill-switch on every cutover. Your product roadmap keeps moving — we never ask for a code freeze.
- W09+
Cleanup + handoff
Decommission the legacy service. Integration test coverage on critical paths. OpenAPI docs. Runbook handed to your team — or we stay on retainer.
Stack
Tools we
reach for first.
Our default .NET stack, chosen for production reliability not resume padding. Already on a stack? We'll slot in — but greenfield, this is where we start.
- Framework.NET 8 · ASP.NET Core · Blazor · Minimal APIs
- LanguageC# 12 · FluentValidation · MediatR · AutoMapper
- StylingTailwind · MudBlazor · Radzen · Bootstrap
- DataEF Core 8 · Dapper · Redis · SQL Server · PostgreSQL
- TestingxUnit · Testcontainers · Bogus · Moq · NBomber
- InfraAzure · AWS · Docker · Kubernetes · Datadog · Sentry
Engagement
Three ways
to work with us.
No hourly retainer that bills for "thinking time." Pick a lane that matches your stage; everything is fixed-quote or transparently rated.
DEDICATED TEAMmonthly
Hire dedicated .NET engineers.
Embedded engineers in your Slack, your Linear, your standups. A scaled pod of senior .NET engineers, augmenting your team. Pause, resize, end with 30 days' notice.
$5k / eng / mo
PER ENGINEER
- Same senior bar as fixed-scope
- Embedded in your team
- Founder-direct escalation
ENGAGEMENTcustom
Strategic .NET partnership.
A long-term partner for product orgs that need both delivery and judgement — architecture program, migration roadmap, hiring help.
custom
PROCUREMENT-FRIENDLY
- Multi-quarter roadmap
- Architecture & hiring partner
- Procurement-friendly paper
FAQ
Sharp questions,
straight answers.
Minimal APIs, migrations, microservices — the questions we get on every .NET discovery call.Minimal APIs for greenfield — leaner, faster to write, pairs naturally with vertical slice architecture. Controllers when you're inside an existing codebase that already uses them and a migration isn't justified. The performance difference is negligible. The clarity difference on a new project is real.
Yes. We put YARP in front of both applications and shift traffic one endpoint at a time. .NET 8 endpoints go live while .NET Framework serves everything else. Kill-switch on every cutover. Your team keeps shipping the whole time.
A modular monolith handles most products and is significantly easier to operate. Microservices earn their place when independent deployment cadences or team-level autonomy is the actual bottleneck — not because the architecture diagram looks cleaner that way.
Yes. The engineers who write the RFC ship the code. No mid-engagement handoff to a junior team. No account manager between you and the people doing the work.
Yes. We adapt to what's there and flag in the RFC where structural changes would materially reduce risk. If your data layer is working, we build on top of it — we don't rewrite it to fit our preferences.
Founder-direct
Tell us whatyou're building.
Thirty minutes with the founder. We'll bring a senior .NET engineer, the relevant playbook, and a candid read on whether .NET is the right tool — or whether something lighter solves your problem for half the cost.