Deploying your first .NET app to velixir

After ten years of writing C# I've used most of the major .NET hosting options. Azure App Service for the day jobs, Heroku for side projects, Render here and there. The frustration was always the same shape, just dressed up differently each time.

Hello World. This is the first post on the velixir blog. If you're considering a move from one of those platforms, this post explains why velixir exists, what it looks like to deploy your first app, and what the managed database and cache side of the platform does.

What I was tired of paying for

Enterprise prices, and you still spend your evenings fighting the dashboard. That was the pattern on every platform I tried, and it got worse the moment I tried to run something I actually cared about.

Take autoscaling. On Azure App Service you can't autoscale at all on the entry tiers. You have to move up to Standard, which costs several times more for the same hardware, before the platform will add a replica for you under load. The one feature that matters most for real traffic is treated as a premium upsell rather than table stakes.

The rest of the experience earns its bill in sprawl. Wiring up a custom domain crosses four separate screens. Logs are split across as many surfaces, each showing an overlapping subset of what you actually want. Basic monitoring feels like an integration project. Half the time I couldn't even tell what I'd be charged, or why nothing in the dashboard was in euros.

Managed Postgres and Redis are their own adventure: separate billing pages, their own pricing curves, a connection string you copy between two consoles every time you spin up an environment. And .NET is often a second-class citizen, supported through a Dockerfile you maintain yourself or a generic runtime that lags a major version behind.

I built velixir because I'd run out of patience for all of it. I wanted a platform that treats running things in production as the default, not the tier you graduate to. It's the platform I wanted to exist. Here's what the result looks like.

The five-minute story

This is what deploying a brand new app looks like end to end.

Step one. Sign up. Visit velixir.net/account/register. Thirty seconds. Email confirmation lands instantly. We don't require a credit card at sign-up, so you can browse around. A payment method only gets attached when you're ready to provision your first paid resource.

Step two. Create the app. Click Create App in the dashboard, pick a plan (Hobby at €3.49/mo is plenty for a side project), pick a region (Central Europe or North America East), and pick a .NET version. The default is whichever LTS Microsoft is currently shipping.

Step three. Connect your code. Two options. If your code lives in a Git host, paste the repo URL and the next push to your chosen branch triggers a build. If you'd rather control deploys from your terminal, link the app once and push:

dotnet publish -c Release
velixir init --app your-app-id   # one-time: links this folder, writes .velixir.json
velixir push                      # ships your publish output; from now on just `velixir push`

The CLI picks up your publish output, ships it to our deploy pipeline, and rolls it out across replicas. Most apps go from "git push" to "serving traffic" in around ninety seconds.

Step four. There is no step four. Your app is live at https://your-app-name-{region}.velixir.run with a working TLS certificate. Point a custom domain at it whenever you're ready.

What's actually happening behind the scenes

The thing I care about most with velixir is that the platform is built around the actual .NET toolchain instead of around a generic container abstraction. Your build runs dotnet publish with the same flags you'd use locally, whether that's the velixir CLI on your machine or a step in your CI. We don't transcode your project into anything else. There's no buildpack in the middle pretending to understand .NET project structure. If dotnet publish works on your machine, it works on velixir.

The result is a release artifact: your publish output, stored durably. Each push creates a new release. We keep your recent ones, up to a gigabyte of build artifacts per app, evicting the oldest first and never the one that's currently serving. Rolling back is a one-click operation that points traffic at a previous artifact. It happens in seconds, and it can't fail in any of the interesting ways that re-running a build can.

Once the artifact is built, we deploy it across the region you chose. Each app gets its own isolated workload, its own internal endpoints, and its own routes through our global edge layer. You see an app, replicas, deploy history, logs, and metrics. The orchestration substrate stays out of your way.

Traffic into your app passes through our edge layer before it touches your replicas. Every app gets network-layer DDoS protection included at the edge, with no add-on and no separate billing line. The application-layer controls that usually sit behind a premium tier (per-endpoint rate limiting and per-IP connection caps) are built in and free to switch on, so you can throttle someone hammering /api/heavy-query without paying extra for it.

Autoscaling is on by default on every plan, including the entry tier. The only thing your plan changes is the ceiling: how many replicas you're allowed to scale out to, not whether you get to scale at all. And the autoscaler is tuned specifically for .NET workloads, so it's fast. When traffic spikes, a new replica starts taking real load within about a minute of coming up. That's quick enough to soak up a surge before your users feel it as latency or errors, instead of leaving capacity that's already running idle while the platform waits to trust it. When the spike passes, the autoscaler hands the replicas back, so you're not paying for capacity you've stopped using.

Managed Postgres, because everything needs a database

Almost every app I've written needs a database. On most PaaS providers you pick a Postgres add-on, the pricing is opaque and structured to scale to "enterprise" before you realise it, and you copy a connection string between two consoles every time you provision a new environment.

velixir's managed Postgres is a first-party service, billed hourly in euros like everything else. It starts at €4.95/mo for a Starter instance, right for side projects and dev environments, and scales through production tiers up to a 4 vCPU / 16 GB Scale instance, so you grow the same database instead of migrating off a "hobby" product. Every tier gets continuous point-in-time recovery (the window widens as you move up), and Standard and above can run with high availability.

Provisioning works the same way as apps. Click Create Database, pick a plan, a region, a Postgres version (17, 16, or 15), and a name. The instance comes up in about a minute. You can connect from psql or your migration tool if you flip on external access, but the more interesting workflow is linking the database to an app from the dashboard. When you link, we inject DATABASE_URL into the app's environment as a ready-to-use Npgsql connection string. Your code reads it and gets on with life:

var conn = Environment.GetEnvironmentVariable("DATABASE_URL");
services.AddDbContext<AppDbContext>(o => o.UseNpgsql(conn));

No credentials in source control. No copy-pasting between dashboards. Rotate the connection and we re-inject the new value on the next deploy.

When you turn on HA, we run a synchronous standby replica so a single node failure doesn't take the database down (it bills as a second replica). Point-in-time recovery uses continuous WAL shipping, so the seven-day window on a Starter instance is a real seven days, you can restore to any second within it.

Managed Valkey for the things that shouldn't hit your database

The other piece of infrastructure most apps need is a cache. We ship Valkey for that role: an open-source, BSD-licensed cache that's wire-compatible with everything you've ever written against the Redis protocol.

In practice this means StackExchange.Redis works without changes. Existing tooling works. Existing dashboards work. We run it as a fully-managed service, billed hourly in euros, starting at €2.45/mo for an ephemeral Starter cache, the right shape for session state in a single-region app, and scaling up to a 2 vCPU / 16 GB Scale instance for cache-heavy workloads. Standard and above add persistence (RDB plus AOF) and scheduled snapshots you can restore from, with the retention window widening as you move up.

Linking works exactly the same way as databases. Click link, pick the cache, and REDIS_URL shows up in your app's environment.

using var muxer = ConnectionMultiplexer.Connect(
    Environment.GetEnvironmentVariable("REDIS_URL"));

Where velixir runs

velixir runs in two points of presence today, one in Central Europe and one in North America East, with more to come. You choose a region per app, per database, and per cache, so you can place each workload close to the users it serves. We bill in euros across every region. The pricing on the page is the pricing on your invoice. No FX surprises, no padded conversion margins, no different price list per region.

High availability is a one-toggle add-on, on apps and on managed Postgres (Standard and up). On Postgres it's a synchronous standby, so a single node failure doesn't take the database down. On apps it's a warm standby you can run in a second region of your choosing: if your primary region goes dark, the edge reroutes traffic to the backup automatically, with no DNS changes and no manual cutover. Configure the standby on a smaller plan if its only job is to absorb traffic during an outage.

What's shipping today

You can deploy ASP.NET Core APIs, MVC apps, Blazor Server apps, gRPC services, background workers, and any other .NET workload that publishes via dotnet publish. Every major .NET version since Core 1.0 is runnable. The actively-supported ones get Microsoft's security patches automatically.

We support custom domains with automatic TLS certificates, environment variables with secrets encrypted at rest, real-time log streaming, runtime metrics, autoscaling on every plan, optional HA with a standby replica (cross-region for apps), atomic rollback, and deploy slots for blue-green or preview environments. Bandwidth is unmetered with no egress fees. Network-layer DDoS protection is included on every app, with built-in per-endpoint rate limiting you can switch on for free. The CLI works on Windows, macOS, and Linux.

I'm genuinely open to feedback. If something doesn't work quite right, or you've got an opinion on how a feature should behave, email me at [email protected] (I read everything) or open a support ticket from the dashboard. velixir exists because I was tired of paying enterprise prices for hosting that didn't quite fit the .NET shape, and I'd rather hear what's missing from you directly than have you quietly give up on it.

The trial

The first month is on me, up to €14.99 of credit. That's enough to run a Hobby app, a Starter database, and a Starter cache for the full month with headroom to spare. The credit lands the moment you add a payment method, you spend it down at the same hourly rates as paid usage, and if you don't burn through it in the first thirty days it expires. We don't extend it. We don't chase you for the difference. We don't retro-bill you.

Sign up at velixir.net, spend fifteen minutes, deploy something. If it doesn't work, tell me what broke and I'll fix it.

Joe Connolly

Founder, velixir