Choosing a Backend Language and Runtime

Beginner · 7 min

How Node.js, Python, Go, Java, Ruby, PHP, .NET, and Rust actually trade off for backend work, and why the "best" one depends on what you're building.

Before thisWhat Does a Backend Developer Do?

Tech With Tim · 7 min

Choosing a Backend Language and Runtime

The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.

Taught by Tech With TimReport a problem with this video
Not started
Set this lesson's status

What you'll learn

  • A backend language choice is really a choice about concurrency model — how the runtime handles thousands of requests arriving at once — and that one decision explains most of the other tradeoffs.
  • Node.js and Python both rely on an event loop and handle I/O-bound work well, but Python's GIL limits true parallel CPU work in a single process in a way Node's single-threaded model was never trying to avoid in the first place.
  • Go and Rust compile to native binaries with lightweight concurrency built into the language, trading a steeper or more unusual learning curve for performance and lower operating cost at scale.
  • Java/JVM, Ruby, PHP, and .NET/C# are all mature, battle-tested ecosystems whose real tradeoffs today are less about raw performance and more about hiring pool, existing codebase, and how much the platform decides for you.
  • None of these languages is strictly the "right" answer — the decision is dominated by team familiarity, the problem's actual performance requirements, and what already exists at the company, in roughly that order.

The decision underneath the decision

“Which backend language should I use?” sounds like a question about syntax or popularity, but the question that actually matters underneath it is: how does this language’s runtime handle doing many things at once? A backend process spends most of its life juggling concurrent requests — while one is waiting on a database query, another one just arrived and needs handling too. How a language and its runtime deal with that single fact explains almost everything else people argue about when comparing backend stacks.

This lesson is deliberately a survey, not a tutorial. Node.js, Python, Go, Java, Ruby, PHP, .NET, and Rust each have (or will have) their own dedicated roadmap here that teaches the language itself. The job of this lesson is narrower: understand what each one is actually trading off, well enough to reason about a real choice instead of guessing from vibes or hype.

Event loops: Node.js and Python

Node.js runs JavaScript on a single thread with an event loop: instead of blocking while waiting on a database call or a file read, it registers a callback and moves on to the next piece of work, coming back when the result is ready. This makes Node very good at handling a large number of concurrent connections that mostly spend their time waiting on something else — which describes a huge fraction of real backend traffic. The cost is that genuinely CPU-heavy work (image processing, heavy computation) blocks that single thread and stalls everything else, unless you explicitly hand it off to a worker.

Python reaches similar territory through asyncio and frameworks built on it, but carries the Global Interpreter Lock (GIL) — a mechanism that only lets one thread execute Python bytecode at a time within a process. For I/O-bound work this barely matters, since the GIL releases while waiting on network or disk. For CPU-bound parallel work within a single process, it’s a real ceiling, usually worked around with separate processes rather than threads. Python’s backend story (Django, FastAPI, Flask) leans on an exceptionally mature ecosystem, especially where a team also touches data or ML work.

Compiled concurrency: Go and Rust

Go was built at Google with backend services specifically in mind, and it shows: goroutines are cheap, lightweight threads the runtime schedules for you, and channels give you a built-in way to coordinate between them without the ceremony of manual thread management. Combined with a fast compiler and a single static binary as the deployment artifact, Go has become a default choice for infrastructure-adjacent services and APIs that need to handle serious concurrent load without a large memory footprint.

Rust goes further on performance and safety at the cost of a harder learning curve. Its borrow checker catches memory and data-race bugs at compile time instead of at 3am in production, which is a genuine advantage for systems where correctness under concurrency is critical — but that same strictness means more upfront friction writing code, especially for a team new to the language. Rust backend frameworks exist and are improving, but the ecosystem is younger than Go’s for typical web API work.

The established platforms: Java/JVM, Ruby, PHP, .NET

Java and the JVM power an enormous share of existing enterprise backend systems, and that’s not inertia alone — the JVM’s garbage collector, mature threading model, and decades of tooling (plus newer additions like virtual threads) make it a genuinely solid choice for large, long-lived systems. The tradeoff is verbosity and a platform that has a lot of opinions about how you structure things, which some teams want and others find heavy.

Ruby, mostly via Rails, optimized hard for developer productivity and convention over configuration — you write less code to get a working feature, at some cost to raw throughput per server compared to Go or a tuned JVM app. PHP still runs a startling share of the web (much of it via WordPress), with a request model — a fresh process per request in many deployments — that trades some performance for simplicity and resilience to one request’s bugs crashing another’s. .NET/C#, especially since .NET’s open-source, cross-platform era, offers JVM-like maturity and performance with a different ecosystem and tooling culture, and remains a common default in Windows-heavy and enterprise environments.

How this actually gets decided

In practice, the choice rarely comes down to a benchmark chart. It comes down to: what does the team already know, what’s the existing codebase already written in, what’s the actual performance requirement (most apps never get close to needing Go-level throughput), and what’s the hiring market like for this stack in your area. A startup optimizing for shipping speed with a small team will weigh this completely differently than a company replacing a system that already serves millions of requests a day. None of these eight is wrong — each one made a different bet about where complexity should live, in the language, the runtime, or the ecosystem around it — and the right pick depends on the problem and the people solving it, not on which one wins an unrelated benchmark.

Check yourself

  1. 01What single property of a backend language explains most of its other tradeoffs?

    Its concurrency model — how it handles many requests arriving at the same time — because that one design decision ripples into performance characteristics, typical use cases, and even how bugs tend to show up.

  2. 02Why doesn't Python's GIL (Global Interpreter Lock) make Node.js "faster" by comparison for a typical web API?

    Most web API work is I/O-bound (waiting on a database or network call, not burning CPU), and both Python's async event loop and Node's single-threaded event loop handle waiting on I/O well — the GIL mainly limits true parallel CPU-bound work inside one process, which a typical request handler rarely needs.

  3. 03What do Go and Rust trade for their performance advantage over Node.js or Python?

    A steeper or more unusual learning curve, and in Rust's case a stricter compiler that catches memory and concurrency bugs at compile time instead of letting you write them quickly and debug them later.

  4. 04For a mature, boring enterprise system, what usually matters more than which language benchmarks fastest?

    Hiring pool, the team's existing skills, and how much the platform (like Java's JVM ecosystem or .NET's tooling) already decides for you — these determine long-term velocity and maintenance cost far more than a few milliseconds of per-request latency.

  5. 05Why is this lesson explicitly "not a tutorial"?

    Because each of these languages already has (or will have) its own dedicated Upshard roadmap that teaches it properly — this lesson's job is only to help you reason about the choice between them, at the level a team actually makes that decision.

Notes

Private to you

Esc
↑↓ navigate↵ open? shortcuts

Keyboard shortcuts

Press Esc to close

Anywhere

⌘K
Search and commands
/
Search
?
This sheet
Esc
Close

Reading a lesson

J
Next lesson
K
Previous lesson
B
Bookmark