At the start of 2026 we made a decision about what Masteringbackend is for, and then spent the year rebuilding the platform around it. Most of that work landed quietly. Learners have been using the result for months without anyone explaining what changed or why.
This post is the explanation. What we decided, what shipped in what order, and what each decision cost us.
Why We Stopped Building a Course Library
Masteringbackend began as a place to learn backend engineering. That's a reasonable thing to be, and it has a clear finish line: the material exists, the videos are recorded, the catalog is full.
The problem is that a full catalog and a job-ready engineer are different achievements. Finishing every video in a course proves somebody finished the videos. It doesn't prove they can design a service, debug it under load, or defend a decision to an interviewer who isn't impressed by enthusiasm.
So we changed what we're accountable for. Masteringbackend is a career engineering platform now, which means we aren't finished when the material exists. We're finished when somebody can do the work.
That turned into an architecture with 3 phases, and everything on the platform has to belong to one of them:
- Learn. Structured backend engineering depth, in an order that holds together rather than a shelf of separate courses.
- Build. Production-grade projects, graded by something other than the person who wrote the code.
- Grow. Interview readiness, and evidence a hiring manager can open without an account.
A feature that doesn't move a learner through one of those doesn't get built. That single rule shaped everything below, and the rules we check work against before shipping are written up separately in how we decide what ships.
1. January to May: Building the Foundation
The first half of the year went on the parts that decide what a learner does next. None of it is glamorous, and all of it had to exist before anything else made sense.
- Mock interviews arrived first, in January. Starting with the Grow phase was deliberate. Interview performance is the clearest signal of whether the rest of the platform is working, and it's the hardest thing to fake.
- Leaderboards followed in February. Project and bootcamp boards, so learners could see how they were doing against other people instead of against a progress bar.
- Onboarding was rebuilt the same month. A learner now says which language they actually want to work in and starts on something relevant, instead of landing in a catalog and guessing.
- Portfolios and global search shipped in February too. Finished work needed a place to sit, and the platform had grown big enough that finding anything in it was becoming a job of its own.
- Learning paths landed in March. This is the piece the architecture depends on. A path is one ordered route through a discipline, mixing 7 kinds of work in a single timeline: videos, articles, quizzes, exercises, projects, mock interviews, and bootcamps. Sequencing a career is our problem now, not the learner's.
- Learning schedules came in May. A learner sets study sessions and gets an email that links back into the exact session booked.
A learning path timeline, showing mixed kinds of work in a single order.
By the end of May the platform could guide somebody. It could point them at one ordered route, mix the right kinds of work into it, and show them where they were. What it still couldn't do was check whether the work was any good. That was the next problem.
2. June: Teaching the Platform to Grade
June was the largest month of engineering work in the platform's history. Nearly all of it served one idea. The platform should decide whether work is finished, not the person who did it.
Three things shipped that make that real.
The exercise playground. Learners write code in the browser in 13 languages, the submission runs on our servers, and each check reports back as it finishes. Grading uses one of 3 methods, and we publish which one applies:
- OUTPUT_MATCH. We run the program and compare what it prints against what the exercise expects.
- FUNCTION_CALL. We call the function the learner wrote with set arguments and check what comes back.
- TEST_CASES. We run a real test suite against the code, using that language's own test runner.
The exercise playground, with each check reporting back as it finishes.
The project playground. A learner opens a project, lands on a runnable baseline, and gets a real terminal and a live server in the browser with nothing installed locally.
Run test. The piece that ties it together. A learner boots their server, clicks Run test, and the platform sends a genuine HTTP request to that running server, grading the response against the task's contract. Where a task has a contract, there's no self-mark button to fall back on.
A failed test run, naming the checks that did not pass.
Around those, June also delivered:
- The path workspace. Every step type in one continuous session that tracks position and advances on completion, instead of a dozen tabs.
- AI mock interviews, rebuilt. A full interview in chat with a code editor and whiteboard inside it, ending in a report that scores every answer separately with notes.
- The MB League. Weekly cohorts of up to about 30 learners at the same tier, across 5 tiers, where promotion and demotion are both real.
- Public portfolios. One page, readable logged out, leading with shipped projects rather than claims.
- GitHub autosave. Project work commits to a repository the learner owns, so the artefact outlives the session.
- Points-based path certificates. Issued at 70% of a path's required points, with the remaining total visible while working.
- Article blocks. Prose, a runnable code editor, and a check-understanding quiz inside a single lesson.
- A redesign, a dark theme, and full mobile support, including the interview code editor and whiteboard on a phone.
3. July and August: Making Proof Portable
Grading work is only half of it. If the proof stays inside the platform, it's worth nothing to the person doing the hiring. The last stretch of the year went on making that evidence usable by people outside the platform.
- Verifiable certificates with QR codes, in July. Anyone can check a certificate at a public URL or by scanning it, with no account and no request to us. That's the whole point: a recruiter shouldn't have to trust us, or sign up for anything, to confirm what somebody did.
- Free practice runs on exercises. Only Submit consumes an attempt, so experimenting costs nothing. The remaining attempts and their reset time are both visible, and a hint shows its price in MB before it's revealed.
- Rewards for the things that matter. Passing a mock interview earns 150 MB.
- GitHub connections that repair themselves. If a connection expires mid-project, a learner reconnects without losing their place.
- Terminal projects, in August. The same grading idea from the other direction. A learner writes a CLI program, passes it input they chose, and gets graded on what the program actually prints.
A certificate, verified with no account and no login.
Everything shipped this year is listed in the 2026 product changelog.
What the Rebuild Cost Us
A year of decisions like these has a bill attached, and it's more useful to name it than to skip it.
- We killed features we liked. Anything that didn't belong to Learn, Build, or Grow got cut, including work that was already underway and would have been popular.
- The catalog is smaller than it could be. Content that doesn't exist yet doesn't get listed, so there's no placeholder to enroll in and no title that opens onto an empty page. We lose the catalog-size comparison on purpose.
- Video is worth the least of anything on the platform. A video is 10 points and a project is 200. The cheapest thing we make, and the easiest thing to sit through, is worth the least. That's the opposite of what makes commercial sense.
- Finishing got harder. Removing the self-mark means tasks take longer to complete, and harder to finish means fewer people finish.
- Proof lives where we don't control it. Certificates verify without an account and project code sits in the learner's own GitHub. Both send people away from the site.
- June is hard to show anyone. It was the biggest engineering month of the year, and almost all of it runs on our servers after somebody clicks a button. What a learner sees is a short list of checks. What it took to make those checks trustworthy never appears on screen.
What This Year Means if You're Hiring or Teaching
If You're Hiring a Backend Engineer
Almost everything above was built so that evidence would survive contact with somebody outside the company. A certificate from here is issued on points rather than attendance and verifies at a public URL with no account. The projects behind it sit in the candidate's own GitHub repository, so what gets read is their commit history rather than our summary of it. And mock interview reports score every answer separately, which means a candidate has usually already seen their own weakest area before an interview happens.
A public portfolio, as a recruiter opens it.
If You Want to Teach Here
Two things get checked before anything else. A course has to belong to Learn, Build, or Grow. And every project task has to be gradeable by something other than the learner's own judgment. That means writing a real contract for it, covering the method, the path, the status code, and the shape of the response. Describing what the finished thing should look like isn't enough.
That's slower than recording a video series, and it's why our approval process takes longer than most.
Summary
In 2026 we stopped building a course library and started building a career engineering platform. The first half of the year laid a spine: mock interviews, leaderboards, rebuilt onboarding, portfolios, search, and learning paths that put 7 kinds of work in one ordered timeline. June taught the platform to grade its own work, through the exercise playground, the project playground, and Run test. July and August moved the proof outside our walls with verifiable certificates and code that lives in the learner's own repository.
It cost us features, catalog size, and a month of engineering that mostly runs out of sight. The 2026 product changelog lists everything that shipped, and how we decide what ships covers the standards each of these decisions was checked against.
