Question 1

Is Koa still worth learning in 2026 given Fastify and Hono exist?

Accepted Answer

Yes if you'll be working on existing Koa codebases (which are common at companies like Alibaba/Egg.js, Paytm, Cred) or if you value framework minimalism. For greenfield projects in 2026, Fastify usually wins on raw performance and built-in features, and Hono wins for edge/serverless deployments. Koa sits in the middle: cleaner than Express, less opinionated than Fastify, and the onion-model middleware idea has shaped how Node frameworks think about request flow. Even if you don't write new Koa code, understanding the model is valuable because the same patterns show up in modern frameworks across multiple languages.

Question 2

How much does a Koa developer earn in India in 2026?

Accepted Answer

₹6-20 LPA for backend developers with Koa in their stack, though most listings ask for Node.js generally and Koa is one of several frameworks you'd be expected to know. Companies hiring Node.js backend engineers in this range: Paytm, Cred, Razorpay, Zomato, Swiggy, Flipkart, and many fintech/D2C startups. Senior roles (₹25 LPA+) typically expect deep system design knowledge alongside the framework chops — knowing Koa specifically rarely commands a premium, but knowing it well as part of a broader Node.js skillset signals you can pick up frameworks fast and care about the underlying primitives.

Question 3

When should I choose Koa over Express?

Accepted Answer

Choose Koa when you want a smaller, more modern framework core and value the onion-model middleware for things like timing, tracing, and centralised error handling. Choose Express when you need the largest possible ecosystem of pre-built middleware, when your team is more comfortable with callback-style code, or when you're hiring at scale (Express knowledge is more common). For most new projects in 2026, the more interesting question is Koa vs Fastify vs Hono — Express's dominance has eroded. If you want to stay on the well-trodden path, Express is still the easiest hire and has the most plugins; if you want a sharper, more modern feel without committing to a heavily opinionated framework, Koa is the natural choice.

Question 4

Does Koa support TypeScript out of the box?

Accepted Answer

Koa ships with TypeScript definitions (via `@types/koa` and `@types/koa__router`) and works well with TypeScript projects. There's no separate TypeScript-first Koa variant the way Fastify has gone — but the explicit `ctx` object means TypeScript can give you good inference once you augment the Koa context interface with your custom state and properties. The common pattern is to declare a module augmentation like `declare module 'koa' { interface DefaultState { user?: User; requestId?: string } }`, after which every `ctx.state` access is typed automatically. For full request/response typing, `koa-zod-router` or hand-written typed handlers give you the static safety equivalent of Fastify's schema-driven typing.

Question 5

What's the relationship between Koa and Egg.js?

Accepted Answer

Egg.js is Alibaba's enterprise framework built on top of Koa. It adds opinionated conventions (folder structure, config loading, plugin system, multi-process architecture) that Koa intentionally leaves out. If you're working with large Chinese tech companies, you'll see Egg.js often; in India and the West, plain Koa or Koa with a custom internal framework is more common. Egg.js is roughly to Koa what Nest.js is to Express — a higher-level framework that bakes in opinions about how a large team should structure code. Both let you escape the conventions when needed by dropping down to plain Koa/Express middleware.

Question 6

How does Koa compare to Fastify for performance?

Accepted Answer

Fastify is faster than Koa in synthetic benchmarks (often 2-3x more requests/second on identical hardware) because of its highly optimised JSON serialisation via schemas and its lighter router. In real-world apps where the bottleneck is usually a database or upstream API, the difference shrinks dramatically. Pick Fastify if you're CPU-bound on serialisation; pick Koa if you value the middleware model or already have Koa expertise on the team. For sub-millisecond endpoints (e.g. a status check returning a static JSON object), Fastify wins clearly; for endpoints that fan out to three upstream services and a database, both frameworks are bottlenecked on I/O and the framework choice is a rounding error.

Question 7

What is Koa and how is it different from Express?

Accepted Answer

Koa is a Node.js web framework created in 2013 by the original Express team. It was designed as Express's spiritual successor after async/await became viable — the whole framework is built around composable async functions instead of callback-style middleware. The core differences are: (1) Koa has no built-in router, body parser, or template engine — you assemble what you need. (2) Every middleware receives a single `ctx` object that wraps both request and response, instead of `req, res`. (3) Middleware runs in a downstream-then-upstream pattern using `await next()`, which makes operations like 'measure how long a request took' trivial. (4) Errors thrown anywhere in the middleware chain are caught by the framework and emit a single `error` event — no `next(err)` plumbing. The trade-off: Koa is leaner and more explicit but you build more yourself, whereas Express ships more out of the box and has a larger plugin ecosystem. In an interview, an extra credit answer is to mention that Koa's design has influenced multiple frameworks since — Hapi adopted similar patterns, Fastify took inspiration for its lifecycle hooks, and Python's Starlette/FastAPI use the same onion-model middleware approach.

Question 8

How do you create a minimal Koa application?

Accepted Answer

After `npm install koa`, you instantiate `new Koa()`, register middleware with `app.use()`, and call `app.listen()`. The simplest middleware sets `ctx.body` to whatever you want returned. Koa serialises objects to JSON automatically and sets the right Content-Type header — strings become text/plain, Buffers become application/octet-stream, and Node streams are piped to the response with proper backpressure. There is no router built in — for production work you almost always pair Koa with `@koa/router`. Note that Koa exports a class (capital K) via `require('koa')` in CommonJS or `import Koa from 'koa'` in ESM, depending on your Node.js setup. The minimum supported Node version for Koa 2.x is Node 12, and Koa 3.x (released 2024) requires Node 18+ and ships as pure ESM — pay attention to which major version your team is on, because the migration involves real work around CommonJS interop.

Question 9

What is the `ctx` (context) object in Koa?

Accepted Answer

`ctx` is the single object passed to every Koa middleware. It encapsulates the Node.js IncomingMessage and ServerResponse along with Koa-specific helpers. Inside `ctx` you'll find: `ctx.request` and `ctx.response` (Koa's enhanced wrappers), `ctx.req` and `ctx.res` (the raw Node objects, used rarely), and aliased shortcuts like `ctx.body`, `ctx.status`, `ctx.headers`, `ctx.method`, `ctx.path`, `ctx.query`. A new ctx is created for every incoming request and lives only for that request's lifetime, so you can safely attach per-request state to it (e.g. `ctx.state.user = currentUser`). The unified shape is a deliberate ergonomic choice — it removes the constant `req, res` repetition that defines Express handlers and makes middleware composition cleaner. Under the hood, ctx is created by Koa via prototype-based delegation: `app.context` is the prototype, and ctx, request, and response are all instances that inherit from their respective prototypes. This is why you can extend the context globally by mutating `app.context` — useful for adding helper methods like `ctx.success(data)` that you want available everywhere.

Question 10

How does middleware work in Koa?

Accepted Answer

Koa middleware is any async function with the signature `(ctx, next) => Promise<void>`. When a request comes in, Koa runs the middleware stack like a stack of layers: each middleware does its 'downstream' work, calls `await next()` to defer to the next middleware, and then continues its 'upstream' work after the rest of the stack has finished. This pattern is called the onion model. Skipping `await next()` short-circuits the chain — useful when you want to bail out (e.g. a 401 from an auth middleware). The same `ctx` is threaded through every middleware, so anything stored on it earlier is visible later. Order matters enormously: a logger middleware mounted first sees every request, an auth middleware mounted before the router protects everything that follows, and a static-file middleware placed before the router serves files without ever hitting your API logic. Forgetting the `await` keyword before `next()` is the single most common Koa beginner bug — the chain still appears to run, but errors aren't caught and timing wraparound logic measures the wrong thing.

Question 11

Explain the onion model in Koa middleware.

Accepted Answer

The onion model is Koa's term for how middleware executes. Imagine each middleware as a layer of an onion: the request enters from outside, passes through every layer downward (downstream), reaches the centre (the route handler), then unwinds back out (upstream). In code, the downstream work is everything BEFORE `await next()`, and the upstream work is everything AFTER it. This is profoundly different from Express, where middleware is more like a pipeline that mostly flows in one direction. The onion model is what makes timing, error wrapping, response transformation, and compression middleware so clean — you can wrap downstream logic without callbacks. The same idea exists in Python ASGI (Starlette/FastAPI) and was inspired in part by Koa. A concrete example: a 'timing' middleware records `Date.now()` before `await next()` and writes an `X-Response-Time` header after — without onion semantics you'd have to hook into an `on('finish')` event manually. The cost of this model is that you cannot 'continue past' an error like Express's error-handling middleware does — if a downstream middleware throws, all upstream code after `await next()` in the layers above is skipped. That's almost always what you want, but it surprises Express veterans who expect to handle errors in the middle of the chain.

Question 12

How do you handle routing in Koa?

Accepted Answer

Koa intentionally has no built-in router — you install `@koa/router` (the official routing package). You create a router instance, attach handlers with `router.get/post/put/del`, and then mount it with `app.use(router.routes()).use(router.allowedMethods())`. The router auto-generates 405 Method Not Allowed and 501 Not Implemented responses when you include `allowedMethods()`, which is good production hygiene. Routes support standard path parameters (`/users/:id`) accessible via `ctx.params.id`, prefixes via `new Router({ prefix: '/api/v1' })`, and nesting via `router.use('/admin', adminRouter.routes())`. The official package was renamed from `koa-router` to `@koa/router` in 2018 — older tutorials still reference the unscoped name, but the scoped version is the actively maintained one. Routes can also have per-route middleware: `router.get('/admin/users', requireAdmin, listUsers)` runs `requireAdmin` before `listUsers`, which is how most Koa codebases compose authorisation checks at the route level instead of via global middleware.

Question 13

How do you parse request bodies in Koa?

Accepted Answer

Koa does not parse request bodies by default. Add `koa-bodyparser` (or `@koa/bodyparser` in newer setups) as middleware before your routes. It populates `ctx.request.body` with the parsed JSON, form, or text payload based on Content-Type. For multipart/form-data (file uploads) you need `@koa/multer` or `koa-multer`, which is a Koa wrapper around the Express Multer middleware. Configure body size limits (`jsonLimit`, `formLimit`) to prevent denial-of-service from huge payloads — defaults are 1mb which is sane for most APIs. A common gotcha: `ctx.request.body` (with the parser) is different from `ctx.body` (which is the response body setter). Mixing them up is a frequent source of confusion when migrating from Express. Note that `koa-bodyparser` also exposes `ctx.request.rawBody` — useful for webhook signature verification where you need the unmodified bytes to compute an HMAC.

Question 14

What's the difference between `ctx.body`, `ctx.response.body`, and `ctx.res`?

Accepted Answer

`ctx.body` is a shortcut/alias for `ctx.response.body` — they refer to the same underlying setter on the Koa Response object. Both go through Koa's response handling: type detection (string vs JSON vs stream vs Buffer), automatic Content-Type, and status code defaulting. `ctx.res` is the raw Node.js ServerResponse — bypassing it skips Koa's logic entirely. The rule: always set `ctx.body` (or `ctx.response.body`). Touch `ctx.res` only when you absolutely need low-level control like writing streams without a Content-Length, and even then prefer Koa's stream support by setting `ctx.body = stream`. A subtle but important detail: setting `ctx.body = null` produces a 204 No Content response (with no body), while not setting it at all means Koa returns 404 if no other middleware handled the request. This is by design and lets you express 'I handled this but there's nothing to return' cleanly without manually setting status.

Question 15

How do you set HTTP status codes and headers in Koa?

Accepted Answer

Set status via `ctx.status = 201`. Koa defaults to 200 if `ctx.body` is set, 204 if not — so you rarely need to set 200 explicitly. For response headers use `ctx.set('Header-Name', 'value')` or `ctx.set({ 'X-A': '1', 'X-B': '2' })` for multiple. Read incoming headers with `ctx.get('User-Agent')` (case-insensitive). For cookies, use `ctx.cookies.set('name', 'value', { httpOnly: true, maxAge: 3600000 })` and `ctx.cookies.get('name')` — Koa's cookie helper supports signed cookies if you set `app.keys = ['secret-key']`. There's also `ctx.append('Set-Cookie', '...')` for response headers that can appear multiple times. Note that header names are normalised to lowercase internally — both `ctx.set('X-Foo', 'bar')` and `ctx.set('x-foo', 'bar')` produce the same output. For setting Content-Type explicitly use `ctx.type = 'text/html'` rather than `ctx.set('Content-Type', ...)` — Koa adds the correct charset and uses MIME shortcuts (`ctx.type = 'json'` becomes `application/json; charset=utf-8`).

Question 16

How do you serve static files in Koa?

Accepted Answer

Use the `koa-static` middleware. Point it at a directory and any request whose path matches a file in that directory is served, with proper ETag, Last-Modified, and gzip support. Place it before your router so static files are served first without hitting the API layer. In production, you'd typically front Koa with nginx or a CDN (Cloudflare, Fastly) and let them serve assets — `koa-static` is fine for local dev, internal tools, or low-traffic admin UIs but burns Node event-loop time on bytes you don't need to push. If you need SPA routing (fallback to index.html for unmatched paths), use `koa-static` for the static directory plus a catch-all route at the end that returns `index.html`. For Indian production setups, most teams put Cloudflare in front and serve assets from R2 or S3 with a long max-age — Koa never sees an asset request once the CDN warms up, which is what you want.

Koa Interview Questions

What is Koa and how is it different from Express?

How do you create a minimal Koa application?

What is the `ctx` (context) object in Koa?

How does middleware work in Koa?

Explain the onion model in Koa middleware.

How do you handle routing in Koa?

How do you parse request bodies in Koa?

What's the difference between `ctx.body`, `ctx.response.body`, and `ctx.res`?

How do you set HTTP status codes and headers in Koa?

How do you serve static files in Koa?

What is `ctx.throw()` and how does it work?

How do you enable CORS in a Koa application?

How do you handle errors globally in Koa?

How do you implement JWT authentication in Koa?

How do you connect Koa to a database (Postgres/Mongo)?

How do you handle sessions in Koa?

How do you write integration tests for Koa endpoints?

What is the difference between `ctx.state` and `app.context` for sharing data?

How do you implement rate limiting in Koa?

How do you stream large responses (downloads, CSV, video) in Koa?

How do you handle WebSocket connections alongside a Koa HTTP server?

How do you compose middleware in Koa using `koa-compose`?

How do you implement file uploads (multipart/form-data) in Koa?

How does Koa handle async errors and unhandled promise rejections?

How do you implement request validation in Koa?

How would you architect a Koa-based BFF (Backend for Frontend) at 5,000+ RPS?

How does the downstream/upstream middleware model affect error handling and observability?

How do you write a custom Koa middleware library that supports both async and sync internals?

How do you migrate an Express application to Koa without a full rewrite?

How do you deploy a Koa application to production (Docker, PM2, monitoring)?

Companies Hiring Koa

Salary Insights

Frequently Asked Questions