3 June 2026 · 4 min read ·

The Backend Love Triangle: Bun, ASP.NET, and Rust

Go and FastAPI had their moment. Then LLMs happened. Here's the new triangle of backend choices for startups.

Listen to article

0:00 / 0:00

The Old World

For years, the backend decision tree for startups looked familiar: Go if you wanted speed without pain, FastAPI if your team lived in Python, Node if you wanted to stay in the JavaScript ecosystem. These choices made sense because they optimised for a real constraint — developer time is expensive, and Rust had a brutal learning curve.

That constraint is weaker now.

LLMs don’t write perfect Rust. But they dramatically lower the activation energy. The borrow checker errors that once burned hours are now resolved in minutes with a good prompt. The “Rust is too hard for a startup” argument has a shorter shelf life every month.

Which means the middle-ground options — Go, FastAPI — lose their main selling point.

The Triangle

Three stacks now share the backend crown, each with a clear job.

Rust — The Perfectionist

Zero-cost abstractions. Correctness enforced at compile time. A borrow checker that makes you prove your program is safe before it runs. Rust’s pitch hasn’t changed — what’s changed is the cost of entry.

Rust attracts a certain kind of engineer: one who’d rather the compiler catch the bug than a customer. That’s not a knock. It’s a worldview, and it produces genuinely reliable software.

Pick Rust when: latency is non-negotiable, you’re building something systems-adjacent (proxies, parsers, embedded services), or your team simply wants to do things right and is willing to let the compiler hold them to it. Axum and Actix-web are both production-ready. The ecosystem is mature enough for most API work.

Bun — The Scrappy Upstart

Bun ships as a runtime, bundler, test runner, and package manager in one binary. Native TypeScript support, fast I/O, and a familiar JavaScript and TypeScript API surface. If your team already lives in TypeScript, Bun removes the context switch entirely — share types, utilities, and validation logic across the stack.

Pick Bun when: you’re a TypeScript-first team, building a fullstack product, or want to share types and logic across the stack without a context switch. Throughput is competitive with ASP.NET — the trade-offs are higher memory usage and a single-threaded runtime. Async works fine; Bun handles concurrent connections without issue. The limitation shows up with CPU-bound work: heavy computation blocks the main thread. Worker threads exist as an escape hatch, but it’s not the default mental model the way .NET’s thread pool is. Elysia and Hono are both solid framework choices on top of Bun.

ASP.NET — The Underrated Workhorse

ASP.NET gets dismissed as enterprise bloat. That reputation is outdated. Minimal APIs in .NET 8+ are terse and genuinely fast. Entity Framework Core handles SQL with first-class migrations. Auth middleware, health checks, and structured logging are all there before you install a single third-party package. Native OpenAPI support landed in .NET 9 — on .NET 8 you’ll add Swashbuckle, but that’s a one-liner.

Where ASP.NET earns its reputation is at scale. The opinionated structure that feels rigid in a small project becomes an asset in a large one — new engineers know where things live, teams move independently, and the codebase stays coherent as it grows. Enterprise isn’t a dirty word; it’s a description of a project that needs to survive its second year.

Pick ASP.NET when: you’re building something that will scale in team size as well as traffic, you want structure that holds up as the codebase grows, or you need a mature ecosystem with first-class SQL, auth, and observability out of the box.

The Exes: Go and FastAPI

Go’s pitch was engineering productivity at scale with C-like performance — designed at Google to tame large, slow-to-compile C++ and Java codebases. It wasn’t positioned as a Rust alternative; it predates Rust’s rise. But in practice it carved out the “good enough performance, easy to hire for” space that Rust was too hard to occupy. That space is shrinking. Go is still a capable language — but “pick Go because Rust is too hard” is a weaker argument in 2026 than it was in 2022.

FastAPI remains excellent for one specific use case: ML inference pipelines where the Python ecosystem is non-negotiable. NumPy, PyTorch, Hugging Face integrations — if your API is fundamentally calling Python ML code, FastAPI is the right call. For everything else, Bun covers the “fast to ship” lane with competitive throughput and a much smaller footprint than a Python process.

The Takeaway

There’s no wrong answer inside the triangle. Rust, Bun, and ASP.NET each have a clear job and a defensible case. What’s harder to defend is defaulting to Go or FastAPI out of habit — choosing familiarity over fit.

Pick the tool with the right shape for your problem. Just don’t let “Rust is hard” be the reason you don’t.

The Old World.

For years, the backend decision tree for startups looked familiar: Go if you wanted speed without pain, FastAPI if your team lived in Python, Node if you wanted to stay in the JavaScript ecosystem. These choices made sense because they optimised for a real constraint ,  developer time is expensive, and Rust had a brutal learning curve.

That constraint is weaker now.

LLMs don't write perfect Rust. But they dramatically lower the activation energy. The borrow checker errors that once burned hours are now resolved in minutes with a good prompt. The "Rust is too hard for a startup" argument has a shorter shelf life every month.

Which means the middle-ground options ,  Go, FastAPI ,  lose their main selling point.

The Triangle.

Three stacks now share the backend crown, each with a clear job.

Rust ,  The Perfectionist.

Zero-cost abstractions. Correctness enforced at compile time. A borrow checker that makes you prove your program is safe before it runs. Rust's pitch hasn't changed ,  what's changed is the cost of entry.

Rust attracts a certain kind of engineer: one who'd rather the compiler catch the bug than a customer. That's not a knock. It's a worldview, and it produces genuinely reliable software.

 Pick Rust when: latency is non-negotiable, you're building something systems-adjacent (proxies, parsers, embedded services), or your team simply wants to do things right and is willing to let the compiler hold them to it. [AE1 K S AH0 M] and [AE1 K T IH0 K S]-web are both production-ready. The ecosystem is mature enough for most API work.

Bun ,  The Scrappy Upstart.

Bun ships as a runtime, bundler, test runner, and package manager in one binary. Native TypeScript support, fast I/O, and a familiar JavaScript and TypeScript API surface. If your team already lives in TypeScript, Bun removes the context switch entirely ,  share types, utilities, and validation logic across the stack.

 Pick Bun when: you're a TypeScript-first team, building a fullstack product, or want to share types and logic across the stack without a context switch. Throughput is competitive with [AE1 S P IH0 DAA1 T N EH1 T] ,  the trade-offs are higher memory usage and a single-threaded runtime. Async works fine; Bun handles concurrent connections without issue. The limitation shows up with CPU-bound work: heavy computation blocks the main thread. Worker threads exist as an escape hatch, but it's not the default mental model the way .NET's thread pool is. [EH1 L IH0 S IY0 AH0] and [HH OW1 N OW0] are both solid framework choices on top of Bun.

ASP.NET ,  The Underrated Workhorse.

[AE1 S P IH0 DAA1 T N EH1 T] gets dismissed as enterprise bloat. That reputation is outdated. Minimal APIs in .NET 8+ are terse and genuinely fast. Entity Framework Core handles SQL with first-class migrations. Auth middleware, health checks, and structured logging are all there before you install a single third-party package. Native OpenAPI support landed in .NET 9 ,  on .NET 8 you'll add Swashbuckle, but that's a one-liner.

Where [AE1 S P IH0 DAA1 T N EH1 T] earns its reputation is at scale. The opinionated structure that feels rigid in a small project becomes an asset in a large one ,  new engineers know where things live, teams move independently, and the codebase [S T EY1 Z] coherent as it grows. Enterprise isn't a dirty word; it's a description of a project that needs to survive its second year.

 Pick ASP.NET when: you're building something that will scale in team size as well as traffic, you want structure that holds up as the codebase grows, or you need a mature ecosystem with first-class SQL, auth, and observability out of the box.

The Exes: Go and FastAPI.

Go's pitch was engineering productivity at scale with C-like performance ,  designed at Google to tame large, slow-to-compile C++ and Java codebases. It wasn't positioned as a Rust alternative; it predates Rust's rise. But in practice it carved out the "good enough performance, easy to hire for" space that Rust was too hard to occupy. That space is shrinking. Go is still a capable language ,  but "pick Go because Rust is too hard" is a weaker argument in 2026 than it was in 2022.

FastAPI remains excellent for one specific use case: ML inference pipelines where the Python ecosystem is non-negotiable. [N AH1 M P AY0], PyTorch, Hugging Face integrations ,  if your API is fundamentally calling Python ML code, FastAPI is the right call. For everything else, Bun covers the "fast to ship" lane with competitive throughput and a much smaller footprint than a Python process.

The Takeaway.

There's no wrong answer inside the triangle. Rust, Bun, and [AE1 S P IH0 DAA1 T N EH1 T] each have a clear job and a defensible case. What's harder to defend is defaulting to Go or FastAPI out of habit ,  choosing familiarity over fit.

Pick the tool with the right shape for your problem. Just don't let "Rust is hard" be the reason you don't.