Northflank - Deploy Stuff Without Kubernetes Nightmares

Northflank is a deployment platform that tries to make Kubernetes not completely terrible. Been around since like 2019, and they basically handle all the shit you don't want to deal with so you don't have to become a kubectl wizard.

Look, K8s is powerful but holy hell is it complex for just wanting to deploy a web app. Last time I tried setting up a simple Node.js app on raw Kubernetes, I ended up with 30+ YAML files and a drinking problem. Northflank just gives you a UI that doesn't make you want to quit programming.

Two ways to use it: let them manage everything on their cloud, or install it in your own AWS EKS, Google GKE, or Azure AKS so the compliance team stops breathing down your neck. Both work basically the same way, which is nice because you won't have to relearn everything when you inevitably need the BYOC option later.

How This Shit Actually Works

Their Managed Cloud: They run everything. You push code, it deploys. That's it. No getting paged at 2am because you forgot to set up disk monitoring.

Bring Your Own Cloud (BYOC): Install their control plane in your existing AWS EKS or whatever cluster you already have. Same interface but everything stays in your account. Good for when your legal team has trust issues with external platforms.

Why People Actually Use This

Most deployment platforms make you configure the same shit three different ways. Northflank actually works out of the box. Push your Docker image, it handles HTTPS and domains and doesn't crash when someone hits refresh.

Biggest win is for AI/ML teams. You can just upload a Hugging Face model and get an API endpoint without spending two weeks learning how ingress controllers work. I tried doing this on raw EKS once and gave up after the third day of troubleshooting certificate issues.

Reality check: This costs more than raw AWS if you're running a bunch of stuff 24/7. But way cheaper than hiring someone who actually knows Kubernetes. Plus, with raw K8s you'll spend so much time debugging networking issues you'll never actually ship anything.

Build System That Doesn't Suck

The CI/CD system works with GitHub, GitLab, whatever you use. Push to main, it builds and deploys. Push to a branch, you get a preview environment. Pretty standard stuff.

What works: Docker layer caching is decent. Builds are usually faster than GitHub Actions, though not by much. Maybe saves you a few minutes per build, which adds up.

What pisses me off: Builds randomly hang sometimes and you have to restart them manually. Happened to me last week - build was stuck for 20 minutes on npm install with no error message. Just sitting there doing nothing. The build logs are also a mess - 500 lines of output and your actual error is buried somewhere in the middle.

Gotchas I learned the hard way: Multi-stage Dockerfile caching is unpredictable. Sometimes it uses old layers when you've changed dependencies. ARM64 builds take forever. And don't even think about builds that need more than 4GB RAM on the free tier - they'll just die with no explanation.

Container Registry: They have one built-in with vulnerability scanning. Works fine, but nothing special. You can also use Docker Hub, AWS ECR, Google Container Registry, or Azure Container Registry if you prefer external registries.

Three Ways to Run Your Code

Services: Regular web apps and APIs. Auto load balancing, health checks, the usual suspects. Scaling works but can take 30-60 seconds to spin up new instances during traffic spikes.

Jobs: Cron jobs and one-time tasks. Great for AI training, data processing, database migrations. Retry logic is solid - actually retries failed jobs instead of just dying silently like some platforms.

Addons: Managed databases - PostgreSQL, MySQL, MongoDB, Redis. Automated backups work (tested this the hard way), point-in-time recovery is clutch when someone runs DELETE FROM users in prod.

Scaling Reality Check

Autoscaling: CPU and memory-based scaling that mostly works. Scales down to zero to save money, scales up when traffic hits. Scale-up isn't instant (30+ seconds) so don't expect it to handle sudden load spikes perfectly.

Resource Plans: Start at tiny instances for testing stuff, go up to beefy ones if you need them. Per-second billing is nice - you're not stuck paying for a full hour when your job runs for 5 minutes.

GPU Support: This is where they actually don't suck. Getting GPU support on other platforms is usually a nightmare. Here it actually works. H100s run about $2.50-3/hour, A100s are cheaper but still pricey. Don't leave them running overnight or you'll get a nasty surprise on your bill.

I tested a 70B model on an H100 and got around 15-20 tokens per second, but your mileage will vary based on batch size and other stuff. A100s are slower but still decent. Cold starts suck though - takes forever to load big models.

The catch: GPUs are hard to get during peak hours. I've waited 15+ minutes for an H100 to become available. And yeah, they're expensive as hell. I accidentally left one running over the weekend once and it cost me like $400. Use spot instances if you can handle interruptions - saves a ton of money.

Companies That Don't Hate It

Sentry: They use it because it's easier than managing their own infrastructure. Makes sense - they want to focus on building Sentry, not babysitting Kubernetes clusters.

Writer: AI writing platform that needed GPU support without hiring a whole DevOps team. The BYOC thing helps keep enterprise customers happy since their data stays in their own cloud.

Some AI startup (I forget the name): Running thousands of training jobs daily with just two engineers. Either their workloads are super simple or Northflank's autoscaling actually works. Probably a bit of both.

Where This Actually Makes Sense

AI/ML Startups: If you need GPUs and don't want to become a Kubernetes expert, this is basically your only good option. Deploy Hugging Face models, run training jobs, scale inference endpoints. Works better than trying to wrangle EKS yourself.

SaaS Companies: Multi-tenant apps that need isolation between customers. Preview environments for every feature branch so your QA team doesn't hate you. RBAC and audit logs for when compliance auditors show up.

Small Engineering Teams: When you have 3-5 engineers and one of them reluctantly handles DevOps. Eliminates most of the infrastructure headaches so you can focus on building features instead of debugging ingress controllers.

The Compliance Stuff

SOC 2 compliant, which means they've checked the enterprise boxes. Audit logging tracks who deployed what when, which is useful when that production outage happens and everyone points fingers.

BYOC for the Paranoid: If your legal team insists data can't leave your AWS account, the BYOC model actually works. Same interface, same features, but everything runs in your VPC so the compliance people can sleep at night.

Most companies use this because they're tired of dealing with infrastructure, not because they love paying extra. But hiring a good DevOps engineer costs $150k+ and you still need them to not quit or take vacation. Sometimes the platform fees are just less painful.