Ship your .NET API. Skip the infrastructure.
Deploy a C# API and let Isoplane handle scaling, traffic, and failover. Pay only for CPU time. Idle time between requests and during await is free.
$ dotnet build Build succeeded. $ isoplane deploy Packaging todo-api ........... ok Uploading 2.1 MB ............. ok Live at https://todo-api.isoplane.app $
Two commands from a working build to a live API. No servers, load balancers, or scaling rules to set up first, and no container or VM images to keep patched.
- Pay for CPU time only
Billed by the millisecond of active compute.
- Waiting is free
Idle time,
await, and egress cost nothing. - Scale to zero and back
Fast starts for surges. Nothing running when idle.
- No load balancers, no failover setup
Traffic and resilience are handled for you.
- Ordinary async .NET
Your editor, your build tools, ordinary async / await.
- Bring your database
Keep state in the database you already use.
Pay for compute, not waiting
Your app is idle here. Not billed.
100ms response. Billed for 10ms of CPU.
Read the .NET CPU billing guide →Say goodbye to slow cold starts
Isoplane runs your app’s startup once at deploy time and snapshots the result. Every new instance starts as a copy of that snapshot.
- Pre-initialise once
The runtime boots, static constructors run, configuration is read.
- Snapshot the memory
The initialised memory becomes the template for this deployment.
- Copy and serve
A new instance is a copy of the template, ready for the first request.
Isolation without the weight
Each instance of your app runs in its own WebAssembly sandbox: isolated from its neighbours, with no OS or filesystem shared between them, and far lighter than a container.
Containers · every app carries its own image and runtime. Cold starts are slow because each instance boots all of it before your code runs.
Isoplane · the runtime is part of the host; each instance runs in its own sandbox. Cold starts are fast because a new instance is a copy of an already-started snapshot.
Bring the .NET you already know
Isoplane’s WebAssembly runtime doesn’t require AOT compilation, and it supports reflection, dynamic LINQ and EF queries, and dynamic assembly execution, so most existing async .NET apps run with minimal modification.
- Frameworks
- ASP.NET Core, Entity Framework
- Execution
- Interpreted by the shared Mono runtime inside WebAssembly
- Tooling
dotnet build,dotnet run, and integration tests against the real sandbox- Coming soon
- Durable instances that keep state between requests, sleep when idle, and pick up where they left off
Built for the APIs you already write
- Public REST APIsTraffic that spikes and goes quiet, without paying for the quiet.
- Backends for SPAs and mobile appsAn always-on API behind your frontend, with your database of choice.
- Webhooks and integrationsEndpoints that mostly wait on other services, which is the part that’s free.
- Internal toolsLow-traffic services that would otherwise sit on a server nobody wants to maintain.
- Side projects and prototypesDeploy in one command and leave it running at no cost while idle.
- Existing ASP.NET APIsWe plan to support ASP.NET and Entity Framework at launch to make porting easier.
Run a real project, free
When the beta opens you’ll be able to create an account, deploy a real project, and run it at no cost. Leave your email and we’ll let you know when it’s live.