Where to Go Next
A look back at what you can now build with Node.js, the two projects that put it all together (the Neighborhood Book Swap API and an API of your own, online with a simple front end), and how to choose your next step among a front end, TypeScript, NestJS, Docker and more MongoDB.
Journeyman · Node.js · Web Development · Updated
After this lesson you can
- Plan a final capstone API that meets every requirement on its list
- Choose a next step after this course, such as a front end, TypeScript, NestJS or Docker
Key takeaways
- You can now build, secure, test and ship a REST API with Node, Express and MongoDB, and put it online at a link.
- The final capstone is an API of your own, with sign-in and roles, validation, tests, CI, a README, a live link and a simple front end.
- A front end turns your API into an app people can use, and TypeScript adds types that catch mistakes before the code runs.
- NestJS gives bigger Node apps a fixed structure, and Docker packs an app with everything it needs so it runs the same everywhere.
This is the last lesson of the course. When you started, node hello.js was new. Now a hiker at a trailhead can open a link to an API you put online. This lesson is for the moment you close the course and ask "now what?": it looks back at what you can do, describes the two projects that pull it all together, and helps you choose what to learn next, based on what you want to build.
What you can do now
Here's the course, as things you can do:
- Run and organize Node programs: modules, npm, the debugger, files, arguments, settings, and a command-line tool with honest errors (Module 1).
- Build a REST API with Express: routes, route and query parameters, middleware, validation and one shape for every error, tested with
node --testand Supertest (Module 2). - Keep its data in MongoDB: filters, sorting, paging, updates and indexes with the official driver, and tests against a throwaway database (Module 3).
- Secure it: hashed passwords, tokens, roles, CORS, security headers, rate limits and secrets kept out of the code (Module 4).
- Make it live: WebSockets that push updates, streams for big files, uploads with limits, and slow work moved off the request (Module 5).
- Ship it: structured logs, settings checked at startup, a health check, ESLint and Prettier, tests on every push, and the API online (Module 6).
That's the back end of most apps you use every day. Anything you can't do yet is a next step, not a wall.
One more project: the Neighborhood Book Swap API
This module ends with its mini-capstone: an API where neighbors list books they're giving away and claim one. It's small on purpose, so the work goes into shipping it the professional way:
- ESLint and Prettier clean, with tests (
node --test, Supertest and mongodb-memory-server) run by GitHub Actions on every push; - pino logs, settings checked at startup and a
/healthroute; - online with Render and a free Atlas cluster, at a link you can send to a neighbor.
The final capstone: your own API
The course ends with the final capstone: an API you design and build yourself, and the course's final assessment (there's no big final test). Choose one of these, or bring your own idea of the same size:
- Habit Tracker: daily check-ins and streaks.
- Pet-Sitting Bookings: sitters, owners, and bookings that can't overlap.
- Club Events: a club of your own design, its events and who may run them.
Whichever you choose, it needs all of these:
- Express with routers, and MongoDB with a document shape your README explains (embed or reference, and why).
- Sign-in with hashed passwords and tokens, and at least two roles with different rights.
- Validation, and one error response shape for every error.
- End-to-end tests with
node --test, Supertest and mongodb-memory-server. - ESLint and Prettier clean, and a CI pipeline on GitHub Actions.
- A README that explains every endpoint, and an
.httpfile to try them. - The API online at a link.
- A simple front end, so it's an app people can use, not only an API.
Plan before you build: list what your API does, and beside each line, which of the eight it covers. The README can start the same way:
# Pet-Sitting Bookings
Owners book sitters for their pets, and a sitter is never booked twice at once.
Live: https://your-service-name.onrender.com/health
Where to go next
There's no wrong order. Choose by what you want to build next:
| If you want to... | Go next to |
|---|---|
| Give your API pages people can use | A front end: JavaScript in Depth on this site, then a framework such as React |
| Catch mistakes before the code runs | TypeScript, JavaScript with types, which runs on Node too |
| Build a bigger API with a team | NestJS, a TypeScript framework that gives every Node app the same structure |
| Ship an app that runs the same on any computer | Docker, which packs an app with everything it needs into a container |
| Go deeper into the database | MongoDB in Depth, this course's partner on this site |
TypeScript adds labels, called types, to your values: you say a trail's miles is a number, and TypeScript points out the line that gives it text, before anything runs. NestJS builds on Express and TypeScript and decides where each part of an API goes, which helps when many people share one codebase. Docker packs your API and everything it needs into a container, so it runs the same on your laptop, a teammate's and a host's.
On ask-codey.com, HTML in Depth and CSS in Depth go further into the page, Data Structures and Big-O, Demystified into how fast your code runs, and Bash in Depth and PowerShell in Depth into the terminal you've used all course. Whichever you choose, keep building: the quickest way to learn the next thing is a small project that needs it.
Check yourself
2 questions to try on the lesson page.
So what
You can build, secure, test and ship an API that real people use from their phones. The next tool you learn builds on that, and the projects you make with it are yours to show.