Technology
.NET backend for a mobile app: why I pick it in 2026
When a mobile app is being planned, almost all the attention goes to what people can see: the screens, the transitions between them, how comfortable it is to use. I understand that and I would set the same priorities at the start, because this is the layer a user judges in the first minute and the one that decides whether they stay. The longer an app lives, though, the more depends on what never shows up on screen. The backend determines how long a list takes to load, what the server bill comes to every month and how much work it takes to add another module.
The choice of server technology is also harder to reverse later than the decision about mobile technology. As long as the API contract holds, the app on the phone survives even a full replacement of the backend, but rewriting the logic, migrating the data and testing all of it under real traffic is always a separate project that somebody has to fund all over again. That is why I prefer to make this decision once and calmly.
Below I explain why in 2026 I reach for .NET wherever an app is meant to live for years, where that recommendation stops applying, and what vendor material tends to leave out: the things the platform does not handle on the developer's behalf, and the libraries that have stopped being free.
What a backend does, and what it does not do for the app
The server runs accounts and lets people in, holds the data, sends push notifications, settles payments and makes sure the same user sees the same thing on a phone and on a tablet. That work cannot be moved onto the device, because it needs one shared set of data and access to the company's systems.
What is not true, though, is the claim that the app on the phone is merely a display for the server. In the projects we run, a good deal of the hardest logic lives on the device: an offline mode with its own database and reconciliation once the network returns, a map showing vehicle positions, communication with hardware over Bluetooth, image processing before upload. Splitting the work between phone and server is its own design decision, not something settled in advance by the choice of server technology.
.NET in 2026: the versions and dates worth knowing
Let me start with the thing that articles about "the best technologies" usually leave out, even though it drives cost over the coming year. Microsoft ships a new version every November: even-numbered releases get LTS status with three years of support, while odd-numbered ones get two.
In practice that comes down to three concrete dates. The current version is .NET 10, released in November 2025 and supported until November 2028. Support for .NET 8 and .NET 9 ends in November 2026. A new project starts on .NET 10 today and needs no version change for the next two years, while anything still on .NET 8 has to get its upgrade into the schedule before the year is out.
I value the predictability of that cycle more than any individual feature. Moving between LTS releases is usually boring in the good sense: you change a number in the project file, rebuild, run the tests, and the bulk of the work turns out to be clearing compiler warnings. Boring does not mean free, though, because somebody still has to be paid for that work and it has to fit into a schedule. In ecosystems where the recommended way to build an application changes every year and a half or so, maintaining a five-year-old product costs many times more. You see it on the invoices rather than in benchmarks.
Performance: where those numbers come from and what survives
.NET is often described as winning benchmarks, so let me say exactly what that means. The reference point is the TechEmpower Framework Benchmarks, where ASP.NET Core placed near the very top for years. Two caveats need adding here. First: the last round dates from March 2025 and the project's repository was archived in March 2026, so this is a frozen picture rather than a living ranking.
Second: the figures of several hundred thousand requests per second quoted alongside those results come from servers with dozens of cores and from code written specifically for the test. A real API with authorisation, several database queries and business logic lands many times lower, and that is how I plan it.
Something practical does survive, though. Performance headroom lowers the server bill, because the same load fits on a smaller machine, and at small to medium traffic a mobile backend runs on one server and a managed database for a very long time. If you want comparative numbers for your own case, the only sensible route is a load test against your own code rather than a table found online.
Security for a mobile API looks different from a website's
Here I have to push back on an argument that shows up in nearly every article about .NET, including ones I once agreed with myself. Yes, ASP.NET Core has mature protection against forged cross-site requests and against scripts injected into generated HTML. The catch is that both address a web application with forms and a session cookie. In a mobile backend the phone authenticates with a token and the server generates no HTML, so neither mechanism protects such an API automatically. Microsoft's own documentation says as much and leaves input validation to whoever builds the API.
One thing genuinely stays on the platform's side: protection against SQL injection. Entity Framework Core parameterises queries by default, and a hand-assembled query has to be sent deliberately through a separate method. The rest is the team's work and I price it that way: you have to validate every incoming field, set up authorisation separately on each API method, store the token safely on the device, and think through how it gets refreshed and revoked.
On the sign-in side, .NET supports OAuth 2.0 and OpenID Connect and ships ready-made providers for Google and Microsoft accounts. Corporate sign-in through Microsoft Entra ID is wired up with the Microsoft.Identity.Web package. One more thing is worth knowing before the estimate: App Store guidelines require an app that offers sign-in through Facebook or Google to also offer a service that collects nothing beyond a name and an email address, lets the user keep that address private and does not gather app interactions for advertising without consent. Sign in with Apple meets those conditions, but it is not the only option that does, and in .NET it needs a package outside what Microsoft ships as standard.
GDPR: the platform helps, the data controller answers
I do not describe technology as "GDPR compliant", because compliance is not a property of a tool. It rests with the data controller and is made up of the lawful basis, data processing agreements with vendors, retention periods, the record of processing activities, handling data subject requests and a breach notification procedure. No server platform settles that, and Microsoft promises nothing of the sort either.
The help is real, though, and it is worth knowing how far it goes. ASP.NET Core Identity ships working code for downloading and deleting account data. The documentation states the caveat immediately: that code covers default identity data only. Anything we add ourselves we handle separately. The rest is on us too: we encrypt the data in the database and record who accessed it and when, which saves a lot of explaining during an audit.
The everyday needs of a mobile app
Push notifications. For Firebase Cloud Messaging, Google publishes the official .NET library. Apple ships nothing for APNs, so you are left calling their API directly or reaching for a community package. When you take over an older project, there is a trap waiting here: the legacy Firebase API was switched off in June 2024, so an integration built on the old server key does not work today and has to be rewritten.
Chat and live position tracking. In projects built entirely on .NET the standard answer is SignalR, which picks the connection method itself and falls back from WebSockets to server-sent events or long polling when it has to. If the app is written in Flutter, though, you need to know that official client libraries exist for .NET, JavaScript, Java and Swift, while for Dart and Flutter there are only community packages. In that situation you either accept that when such a package stops keeping up with SignalR you will be fixing it yourself, or you go with plain WebSockets or gRPC, both of which Flutter handles without an intermediary. In new mobile projects I pick gRPC more often.
Background work. Reports, outgoing messages and reminders are handled by the background services built into the platform itself, so for simple cases I add no library at all. For elaborate schedules and clustered work I reach for Quartz.NET, which carries an Apache licence. Hangfire is more convenient for simpler jobs, but its core is licensed under LGPL: the Pro extension starts with the plan costing 500 USD a year and the higher Ace extension with the one costing 1500 USD. That matters to the legal department as much as to the budget.
Message queues. The choice starts with the queue server itself, the broker: usually RabbitMQ, Azure Service Bus or Kafka. We work with a broker straight through its client library, or through a wrapper that adds serialisation, retries and error handling. The options here are Rebus and Wolverine, both under the MIT licence, and MassTransit, for years the default in this ecosystem. That last one moves to a commercial licence in version 9: companies with revenue below one million dollars can apply for a fee waiver, everyone else pays a subscription, and support for the free version 8 ends with 2026.
Payments. Stripe publishes an official .NET library. The Polish gateways PayU and Przelewy24 are wired to the server through their APIs, because neither ships an official server library for this platform. What you find online comes from the community. On the app side it is easier: Przelewy24 does publish an official Flutter library.
Response times. Output caching is built into the platform and Redis is added on top once traffic grows. It is one of the cheapest changes you can make on the server, and the user feels the difference in list loading straight away.
How .NET talks to a Flutter app
We build mobile apps in Flutter, so on every project with a C# backend the question comes up whether the two sides will get along. The answer is short: an ordinary API joins them, so the server technology does not constrain the choice on the phone or the other way round.
In practice the backend publishes a description of its API in the OpenAPI standard, and on the Flutter side we generate a Dart client and its data models from it. That way, when a field disappears from the contract or changes type, regenerating the client produces a compilation error in the app rather than a surprise for the user. Where payload size and latency matter, the same backend can be exposed over gRPC, which Flutter also handles without extra packages.
What really needs thought here is the real-time communication described above. Beyond that, .NET on the server and Flutter on the phone produce no surprises, and splitting the teams on either side of the API contract works well even when the backend is built by the client's own team and we are responsible for the app alone.
It also works the other way round: sometimes we are the ones taking over an existing backend. The same contract then lets us work module by module. We start with the module causing the most trouble and replace it behind an unchanged API, instead of rewriting everything at once.
Scaling: start with a monolith
The biggest advantage of .NET here is that it forces nothing on you at the start. Support for microservices is not an advantage in itself, because every serious server platform has it today and an identical paragraph could be written by the makers of Java or Go.
For a first version of a product, a properly organised monolith is enough, meaning one server application with clearly separated modules: orders, payments and accounts each in its own. Projects that begin with a dozen microservices "for the future" pay for it first during the build. Then they pay again with every change that suddenly touches three services and has to be released in the right order.
I split only when there is a real reason for it: one module puts a disproportionate load on the system, or a separate team works on it and does not want to wait for other people's releases. I will not promise that the split will be painless, because it never is, on any platform. The trouble lies in the data and in the transactions, because after a split one operation spans two databases and cannot be rolled back with a single command. On top of that, a single request is harder to follow through a distributed system once something breaks. The platform helps with the easy part, running and connecting the services, and that is as far as I would count on it.
Costs
The platform itself costs nothing, because .NET is MIT licensed, with no fees and no restrictions on commercial use. Hosting is up to you: Azure, AWS, a plain virtual server or the company's own machines, and Linux is supported on equal terms with Windows. Linux is where these applications most often run.
One caveat has to be spelled out, though, because a paid licence usually comes to light halfway through a project, once the library is already wired into the code. Add-on libraries can carry a price, as with Hangfire and MassTransit above, and with closed components for reports or charts the bill can quickly overtake the cost of the server. I go through the dependency list with that in mind at the start of a project rather than at licence renewal.
Over a longer horizon, the availability of people matters too. C# has been present in corporate projects for over twenty years. The risk of finding nobody to take the code over in five years is markedly lower here than with a technology having its one good moment. If you are estimating the total cost of a project, our ranges for each type of app are in the article on what a mobile app costs, and the scope of what we do is described in our offer.
When I do not choose .NET
No technology is right for everything, and I would rather say plainly when I advise against this one.
For a two-week prototype with an uncertain future, standing up your own API is a waste of time and money. A backend service on a subscription, Firebase or Supabase for instance, gives you sign-in, a database and notifications in a few days rather than weeks. Moving a proven product onto your own infrastructure is expensive, but at that moment there is still little logic to carry over. Rewriting it works out cheaper than building a full backend for an unproven idea.
If the client's own team is going to maintain it and knows another language well, I go with the language they know. A backend in a technology the team understands will be maintained better than a theoretically faster one. With that faster one, every bug sends you hunting through forums. We build backends in more than .NET ourselves: Firebase, Django or FastAPI, depending on the project.
For functions that run occasionally and are billed per invocation, what counts is the time to first response after an idle period. There I check the alternatives rather than assuming .NET wins. The results depend on the specific cloud service more than on the platform itself.
Finally, if a mobile app is meant to work entirely offline, or if all its value sits in processing done on the device, a backend may not pay for itself at all. In that case the conversation about which server framework to pick is premature.
In closing
I choose .NET when an app is meant to be developed for years, when security and integration with company systems matter, and when somebody on the client's side will still be maintaining the product in five years. It gives a predictable release cycle, very good performance at low server cost, and an ecosystem where the basics rarely have to be built from scratch, although add-on library licences now need more careful reading than two years ago.
It does not excuse the team from thinking about API security and it does not take GDPR compliance off their hands. It will not make splitting a monolith painless for anyone either. If you are planning a mobile app and weighing up the backend, get in touch or work out a rough cost in our estimate tool. We are equally happy to tell you when we think .NET is simply too heavy for your project.
Frequently asked questions
Which .NET version should I start a project on in 2026? +
The current release is .NET 10 with LTS status, shipped in November 2025 and supported until November 2028. Support for .NET 8 and .NET 9 ends in November 2026, so projects sitting on those versions should have their upgrade scheduled before the year is out.
Will a .NET backend work with an app written in Flutter? +
Yes, the two sides are joined by an ordinary API, so the server technology does not constrain the choice on the phone. From an OpenAPI description we generate a Dart client together with its data models. The only part that needs thought is real-time communication, because SignalR has no official client library for Dart and Flutter.
What does it cost to run a .NET backend? +
The platform itself is free under the MIT licence, so you pay for hosting and for the team's work rather than for licences. Watch the add-on libraries: the Pro extension to Hangfire only comes with the plan at 500 USD a year and Ace with the one at 1500, while MassTransit moves to a commercial licence in version 9.
Does .NET make an app GDPR compliant? +
No, because compliance is not a property of a tool. It rests with the data controller and is made up of the lawful basis for processing, data processing agreements, retention periods and the handling of data subject requests. The platform helps, for instance with ready-made code for downloading and deleting account data, but that code covers default identity data only.
Does the backend have to be split into microservices from day one? +
No. A well-organised monolith with clearly separated modules is enough for a first version, and the split is worth making only once one module loads the system out of proportion to the rest or a separate team works on it.
Can an existing backend be moved to .NET without rewriting the mobile app? +
Yes, provided the same API contract is kept. The app on the phone then does not need to know that the server behind it has changed. We run these takeovers module by module, starting with whichever area causes the most trouble, rather than rewriting everything from scratch.
This article was originally written in Polish. Read the original version