Routing by Hand

Routing is the logic that decides which response to send based on the request's URL path and HTTP method — and before frameworks like Express, you write it by hand with conditionals on req.url and req.method.

Learn Routing by Hand in our free Node.js course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Node.js course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

By the end of this lesson you'll route requests with plain if and switch statements, parse paths and query strings safely with the URL class, and build a small method-aware route table that returns JSON with proper status codes like 404 and 405.

What You'll Learn in This Lesson

1️⃣ Routing with if on req.url and req.method

A Node server's request handler runs for every incoming request, no matter the URL. Routing is simply the code inside that handler that inspects the request and decides what to send back. The two properties you check are req.url (the path, like /about ) and req.method (the verb, like GET or POST ).

The pattern is: check a condition, respond, and return so no other branch runs. The crucial last branch is the 404 fallback — without it, unmatched requests hang forever because you never called res.end() . Read every line below, then run it.

2️⃣ Parsing the URL and Query Strings

There's a trap in Section 1: req.url includes the query string . A request to /greet?name=Sam has a req.url of "/greet?name=Sam" — so a plain req.url === '/greet' check silently fails. The fix is the built-in URL class.

Build a URL with new URL(req.url, 'http://localhost') (the second argument is a required base, since req.url is relative). Then url.pathname gives you the path with no query, and url.searchParams.get('name') reads query values safely.

3️⃣ Method-Aware Routing and a Route Table

Real APIs serve the same path differently depending on the method: GET /users lists users, while POST /users creates one. So you branch first on the path, then on req.method inside it. Status codes matter here: send 200 for a successful read, 201 Created after a POST, 404 when the path doesn't exist, and 405 Method Not Allowed when the path exists but the verb is wrong.

To return JSON, set 'Content-Type': 'application/json' and pass your object through JSON.stringify(...) . A small sendJson helper keeps every branch tidy and consistent.

Your turn. The handler below works once you fill in the blanks marked ___ . Follow the 👉 hints, run it with node server.js , and compare with the expected output.

Mini-Challenge: A Tiny Todo API

No blanks this time — just a brief and an outline. Build the route table yourself, run it, and check your output against the example in the comments. This is exactly the kind of hands-on routing that makes Express click later.

Common Errors (and the fix)

• Forgetting the 404 fallback — If no branch matches and you never call res.end() , the request hangs forever (the browser spins, curl never returns). Always finish with a catch-all that writes a 404 and ends the response.
• Comparing req.url with the query string attached — req.url is "/greet?name=Sam" , not "/greet" , so an exact match fails. Parse it with new URL(req.url, 'http://localhost') and compare url.pathname .
• Not checking req.method — Matching only on the path means a POST hits your GET logic. Check both, and return 405 (with an Allow header) when the path matches but the verb doesn't.
• Trailing-slash mismatches — /about and /about/ are different strings, so one slips through to the 404. Normalise the path (trim a trailing slash) or match both forms.
• Case sensitivity — /About won't match '/about' . Pick a convention; if you want case-insensitive paths, lowercase url.pathname before comparing.

Pro Tips

• 💡 Always return after responding: once you've called res.end() , returning prevents a later branch from trying to write to an already-finished response.
• 💡 Normalise once, compare many: compute const path = url.pathname at the top of the handler so every route checks the same clean value.
• 💡 This is what Express does: app.get('/about', ...) is the same method-plus-path check you just wrote — frameworks save typing, not understanding.

📋 Quick Reference — Manual Routing

Concept

Node Syntax

Request path (+ query)

req.url

HTTP method/verb

req.method

Parse the URL

new URL(req.url, base)

Path without query

url.pathname

Read a query param

url.searchParams.get(k)

Send JSON

JSON.stringify({...})

Not found

res.writeHead(404)

Frequently Asked Questions

🎉 Lesson Complete!

• ✅ Routing decides the response from req.url and req.method
• ✅ Always end with a 404 fallback so requests never hang
• ✅ Parse with new URL(req.url, 'http://localhost') and compare url.pathname
• ✅ Read query values with url.searchParams.get('key')
• ✅ Branch on req.method and return 405 for wrong verbs
• ✅ Send JSON with 'Content-Type': 'application/json' and JSON.stringify
• ✅ Next lesson: Async Patterns — callbacks, promises, and async/await

Practice quiz

Continue this course

• Previous: Building a Server
• Next: Async Patterns (callbacks → promises → async/await)