How This Course Works

How MongoDB in Depth works on ask-codey.com, from reading a lesson and running its queries in mongosh to exercises checked by tests, chapter checks, module assessments and the projects you build.

Novice · MongoDB · Updated

By

After this lesson you can

  • Describe how this course's lessons, Check yourself blocks, exercises, chapter checks, module assessments and projects fit together

Key takeaways

  • The course has five modules. Each one ends with a mini-capstone, a project of its own, and an assessment that passes at 80%, with three tries a day.
  • Skills are short "you can do this" statements. They are what the questions test and what your progress counts.
  • A wrong answer in Check yourself is useful news, not a failure. Read the explanation, look back at the lesson, and carry on.
  • In an exercise you write mongosh queries in queries.js, and npm test runs them on a throwaway database. It's done when every test passes and you've handed it in.
  • Covered counts the lessons you've finished. Mastered counts the skills you've shown you know, with three clean answers to questions that come at each skill from at least two different angles.

This course is self-study: you go at your own pace, and the course itself tells you how you're doing. Here is what it's made of, and how to get the most from each part.

The shape of the course

Part What it is
Module A big stage of the course, ending with a project. This course has five.
Chapter One subject, such as Getting Started with MongoDB or Finding Documents
Topic A group of lessons inside a chapter
Lesson One idea, explained with small examples you can run

The five modules, and the project each one ends with:

Module What you learn The project
1. Documents Setting up MongoDB, your first documents, and what a document is and when it fits Recipe Collection
2. Queries Finding, sorting, changing and deleting documents Recipe Search
3. Modeling Shaping an app's data as documents, patterns, rules and transactions Bike Shop Store Model
4. Aggregation and Indexes Reports built step by step, and indexes that make queries fast Sales Report
5. MongoDB in an App Using MongoDB from a Node.js web API with the official driver Pet Adoption Data Layer

Each lesson has a level from 1 to 4. Level 1 is meeting an idea for the first time; higher levels go deeper into the same subject.

Skills and Check yourself

Most lessons start by listing their skills: short "you can do this" statements, such as Add a document with insertOne and list a collection's documents with find, and read what each one gives back. Skills are what the questions test, and what your progress counts.

Run every query a lesson shows in mongosh on your own computer, the shell you install in this chapter: typing it yourself and comparing your answer with the page is the practice. A few lessons in Module 5 also have a Do it, a small task solved in a box right on the page.

Near the end of a lesson, a Check yourself block asks one to three short questions about what you've read, then shows you the answer and why. If you get one wrong, that's useful news, not a failure. Read the explanation, look back at the lesson, and carry on.

Exercises

Lessons whose titles start with Exercise: give you a small exercise: starter code in a repository on GitHub, and tests, small programs that check your work for you. In Modules 1 to 4 your work is mongosh queries, written in a file named queries.js, one in each function, the way the comment above it asks. You copy the starter to your computer with Git, open it in VS Code, and run the tests in its terminal:

npm test

npm test runs node --test, Node.js's built-in test runner: it runs your queries on a throwaway MongoDB that the tests start and stop themselves, then lists which tests pass and which fail. At first they fail, and that's expected: each query you finish turns its test green.

When every test passes, you hand the exercise in: you push your work to a repository of your own on GitHub and submit its address on the lesson page. That's what completes an exercise lesson. Get the Exercise Code with Git and Hand In Your Work with Git show each step.

Checks, assessments and projects

  • A chapter check is a short quiz on the chapter's skills, with a few questions from the chapter before to keep them fresh. Take it whenever you like, as often as you like: it's practice, and it tells you what to review.
  • A module assessment ends each module. 80% passes. You get three tries a day, then a 24-hour rest before the next three.

Every attempt draws different questions, so a retake is a fair new try, not a memory test.

  • A mini-capstone ends every module: a project you build with everything the module taught, such as the Recipe Collection at the end of Module 1. It comes with a brief, starter files, milestones that break it into steps, and a short checklist, called a rubric, that you score your own work against. None of them needs another one finished first.
  • The final capstone is the course's final assessment, and there's no big final test. You design the data for an app of your own, explain each choice, and say when you'd choose a table-based database instead.

Covered, Mastered, and who gets what

When you're signed in, the course keeps two separate records of your progress:

  • Covered: the lessons you've finished.
  • Mastered: the skills you've shown you know. A skill is mastered when you answer three different questions about it cleanly, meaning right the first time and without a hint, and those questions come at it from at least two different angles: one might ask how many documents a query finds, another which line of a query to fix. A later miss drops it back, so mastery stays honest.

Everyone can read every lesson and answer its questions. Signed in, your answers count toward your skills, and you can tick lessons as done. With Premium, or if you own this course, you also get course progress on every page, the chapter checks, the module assessments, and the Certificate of Completion: every lesson covered and every module assessment passed.

A good rhythm: read a lesson and run its queries in mongosh, answer Check yourself, do the chapter's exercise, take the chapter check, and when a module's skills are mastered, take its assessment and build its project.

Check yourself

1 question to try on the lesson page.

So what

The course is built so you always know where you stand: what you've read, what you've mastered, what to practice next, and what you've built.

Key terms