Where to Go Next

Look back at what you can do after MongoDB in Depth, from your first document to the data layer of a real API, and choose a next step, from building the server in Node.js in Depth to replica sets, sharding and Atlas's own features.

Journeyman · MongoDB · Updated

By

After this lesson you can

  • Match a next goal to its next step, from building the server in Node.js in Depth to replica sets, sharding and Atlas Search

Key takeaways

  • You can design documents for an app's questions, query and change them, report with pipelines, prove your indexes with explain(), and build a tested data layer behind an API.
  • Your exercise repos on GitHub show that work, and an API of your own, with a model you can explain, shows it best.
  • Running MongoDB for real adds replica sets for copies, sharding for size, and backups and security, which this course named but didn't teach.
  • Node.js in Depth builds the server side of the same stack, and a relational database is the other half of what most teams use.

At the start of this course, a database was somewhere data went. Now you can decide what each document looks like and why, ask it the questions an app's screens ask, and put it behind an API that answers errors properly. This lesson looks back at that, and helps you choose what to learn next, whether that's building the server, running MongoDB for real, or the relational half of the picture.

What you can do now

After MongoDB in Depth, you can:

  • set up MongoDB, mongosh and Compass, and store documents with the right types, from numbers and dates to exact money;
  • find documents with filters and operators, reach into arrays and nested documents, and choose, sort and page the results;
  • change documents with update operators and upserts, and delete only what you meant to;
  • model an app's data from the questions it asks: embed or reference, the common patterns, $jsonSchema validation, and a transaction where one is needed;
  • report with aggregation pipelines, and make queries fast with indexes that explain() proves are used;
  • build a data layer behind an API with the official Node.js driver, with the right status for every error and tests on a throwaway database;
  • read the same work in Mongoose and in C#, and say what Azure's MongoDB-compatible services change.

Look back at your first recipe card from Module 1, braces and quotes and all. Then look at the data layer you finished in this module. That's the distance you've covered.

Show your work

Every exercise you handed in is a public repo on GitHub with your name on it: the recipe finders, the bike shop's order model, the sales reports and the pet adoption API's data. Pin the ones you're proudest of on your GitHub profile, and in each README write two sentences on what it does and one decision you made, such as why the orders embed their line items.

The strongest thing to show is an app of your own. Pick something with data you care about, such as a book club's reading lists, a community garden's plots and waiting list, or a food truck's weekly locations, and build its API with everything from this course: a model you can explain, validation on every collection, the indexes its queries need, one report, and tests. Then write down when you'd have chosen a relational database for it instead, and why. Being able to say that is what makes your choice of MongoDB believable.

What MongoDB does beyond this course

Your MongoDB is one server on one computer. Production systems add a few things this course named without teaching:

  • Replica sets. A replica set is several servers holding copies of the same data, so one can fail and the app keeps going. You started a one-member replica set for Transactions, and Why You'll Need Them Less; a real one usually has three members.
  • Sharding. When one server can't hold all the data, sharding splits a collection across several servers by a field called the shard key, such as a customer's id. Choosing that key well is its own skill.
  • Backups and security. Users and roles, network access rules, encrypted connections and tested backups. Atlas does much of this for you, and a self-run server needs all of it.
  • Atlas's own features. On MongoDB Atlas, Atlas Search gives full-text search with relevance ranking, past what a text index does, and Atlas Charts draws dashboards straight from your collections.

Where to go next

Pick by what you want to build:

Your goal A good next step
Build the whole API yourself: routes, sign-in, deployment Node.js in Depth, the server side of the same stack
Write more JavaScript with confidence JavaScript in Depth
Run MongoDB for an app people rely on Replica sets, backups and security, starting with Atlas
Handle data that's mostly tables of rows A relational database, such as SQL Server or PostgreSQL

For the last one, When a Relational Database Is the Better Choice lists the signs. Most teams use both kinds of database, so learning the other one makes you better at choosing, not less committed to this one.

Check yourself

2 questions to try on the lesson page.

So what

You can now design, query, report on and build behind a MongoDB database, and explain each choice you made. Choose the next step that fits what you want to build, and start with a project of your own.

Key terms

Related