Leetcode Mastery Scheduler puts an FSRS review queue inside the problem page

The problem it solves is forgetting, not problem selection

Leetcode Mastery Scheduler, abbreviated LMS in the README, is a browser extension for Chrome and Edge that turns practice problems into a spaced repetition system. The description in the repository puts it as mastering LeetCode with the Anki FSRS algorithm: automatic problem recommendation and daily review.

The framing matters, because it is not a problem recommender in the way a tagged practice list is. The README describes the core idea as training the memory curve, evaluating priority intelligently and reviewing in a flexible way, so that knowledge moves from short-term to long-term memory through scientific spaced repetition.

So the unit of work is a problem you have already solved, and the problem the tool solves is that you will forget how you solved it. Most people preparing for an algorithm interview do not have a shortage of problems to attempt, they have a shortage of problems they can still solve a month later. That is the gap this extension is aimed at.

The implementation choice that matters is the algorithm. The dependencies include ts-fsrs, a TypeScript implementation of the FSRS scheduler, and the README states that the built-in Anki FSRS algorithm schedules the next review based on your rating of how well you knew the problem.

FSRS is the modern spaced repetition algorithm, and using an existing implementation of it rather than a home made heuristic is the reason the timing is worth trusting. The primary language of the repository is JavaScript, the licence is MIT, and the project was forked from PMCA, Practice Makes Code Accepted, with the README saying it keeps the repeated review idea while optimising for reviewing within limited time.

That last point is the interesting divergence. A general spaced repetition system assumes unlimited time and repeats everything that is due. A practice scheduler for interview prep does not have that luxury, so it needs to rank. The README names a smarter priority evaluation algorithm as one of the improvements over the original project.

A rate button on the problem page, and what happens after you click it

The usage section describes six steps, and the first one sets the tone of the whole design: install and enable the extension, and a rate button appears in the bottom right corner of the LeetCode problem page, with a draggable position.

Embedding the rating control in the page rather than in a separate dashboard is the whole interaction design. You solve a problem on LeetCode, you click the button where you already are, and you rate your mastery. Nothing new to open, no context to switch, and the button can be dragged to where your hand already is.

After the rating, the extension computes the next review time for that problem using the FSRS scheduler. The README's third step describes the daily recommendation: the system calculates the memory retention rate of each problem using the forgetting algorithm and recommends the problems due for review today.

Memory retention rate is the FSRS output that matters here. A model predicts, for each card, the probability that you will still recall it at a given moment in the future. A card whose predicted retention has fallen below the threshold is due. Turning that into a to-do list is the entire value proposition of the extension.

Review can then be completed in one of two ways: mark the problem as reviewed from the extension popup, or rate it from the rate button on the LeetCode page. Both routes feed the scheduler, so a review that happens to coincide with re-solving a problem is recorded rather than wasted.

The fifth step covers management. A Problems tab lists everything you have rated, and supports adding notes, searching and filtering, and exporting all notes as Markdown files. The export matters more than it sounds, because the notes are the part that is genuinely yours and the part that is not stored in the scheduler.

Where the data lives, and the ceiling on Chrome sync

Storage is the part of this extension most likely to surprise you, and the README is unusually specific about it.

There are two options. The default is Chrome sync, where signing into the same Chrome account with sync enabled carries the extension data between devices. The second is WebDAV sync, and the README recommends the Chinese cloud storage service JianGuoYun for it, with an application password created under the security options for third party applications, and the instruction to fill the username and that application password into the extension settings rather than the account login password.

Both routes exist because Chrome sync has a limit. The README states the Chrome sync route has a memory ceiling of roughly 300 problems, and that if you exceed it you should use the WebDAV route instead.

That is a hard number and it is worth understanding what it means. Chrome sync uses a quota rather than a document store, so a large set of review records, each with its own scheduling state, hits a ceiling. A user with a few hundred rated problems is fine. A user with a thousand is not.

The WebDAV route has no such limit according to the README, and it doubles as a backup mechanism. The README suggests running one sync manually after first enabling it so a copy exists on the server, and syncing periodically after that. The framing of the WebDAV backup as unlimited, with the note that the review records will last a lifetime, is a small piece of marketing but the underlying claim, that it is a file store rather than a quota, is the reason it solves the ceiling problem.

The extension also collects FSRS training data, which the README lists as a completed feature intended for testing against the official FSRS training endpoint.

Building it from the repository, and the release scripts

The extension is published to the Chrome Web Store, and the README explains the release sequencing: store review takes a long time, so new versions are published on the GitHub releases page first, and go to the store once approved.

So there are two install routes. The Chrome Web Store listing is linked from the README, and the Edge add-ons listing is also linked but marked as not restored. The third route is the GitHub releases page, which gives a zip that you unpack locally and install in developer mode.

The repository is a normal Node and webpack project, and package.json gives you the whole script surface.

  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage",
    "build": "webpack",
    "manifest:dev": "cross-env NODE_ENV=dev node ./deploy/generate-manifest.js",
    "manifest:prod": "cross-env NODE_ENV=prod node ./deploy/generate-manifest.js",
    "release:dev": "npm run build && npm run manifest:dev && node ./deploy/zip.js",
    "release:prod": "npm run build && npm run manifest:prod && node ./deploy/zip.js",

The pattern is clear from the names. The build step runs webpack, then a manifest generator produces the extension manifest with NODE_ENV set to dev or prod, then a zip step packages the result. The deploy:dev and deploy:prod scripts chain the whole sequence with a clear step in front, so a developer can produce an unpacked extension directory to load in developer mode.

The test setup is Jest, with the usual watch and coverage variants, and the repository has a jest.config.js and a tests/ directory. The webpack configuration lives in webpack.config.js, the extension entry is src/popup.js according to the main field, and popup.html sits at the top level.

There is a manifest.base.json at the top level and a deploy/ directory holding the generator scripts, which is the arrangement that lets one manifest template produce a dev build and a production build with different settings.

What the roadmap table says is not finished

The README includes a status table, and it is more useful than a feature list because it marks what is pending.

Completed items include multi-device cloud sync for Edge and Chrome, monitoring reminders for Bilibili and YouTube, adding LeetCode problems by URL, adding custom cards by URL for recording interview hand-written problems, a notes feature with Markdown export of all notes, collecting FSRS training data, hooking into the official FSRS training endpoint, and WebDAV sync through JianGuoYun.

The pending items are where the limits are. Language switching is not done. Switching between different problem data sources is not done, with the note that only the international and Chinese LeetCode sites are supported currently and other sites such as Luogu are not yet compatible. Firefox compatibility is not done. And the ctrl plus enter shortcut is not done, with the note that its priority is low.

The custom card feature is worth a note because it is the escape hatch. Adding a custom card by URL is described as a temporary substitute for recording interview hand-written problems and for users of other practice sites, which means you can put a non-LeetCode problem into the same review queue even though the site integration is not finished. The URL-based LeetCode problem addition is described as intended for people practising with an IDE.

One entry has an honest caveat attached to a completed feature. The FSRS training endpoint integration is marked complete with the note that only local review record training is supported, and that cloud sync users may be affected. That is the kind of qualification worth noticing, because it means the model quality you get may differ depending on how your data is stored.

For a browser extension in the 0.1.x line, the ratio of shipped to pending is high, and the pending list is specific rather than vague.

Where the scheduler is the wrong tool

Three cases, and they are worth stating plainly because the extension is popular enough that people reach for it in situations it does not cover.

The first is if you need coverage of other platforms. LeetCode is the supported source, and the alternative data sources are listed as pending with Luogu named explicitly. You can add a custom card by URL for one problem at a time, which is a workaround rather than integration, and it does not give you the automatic per-problem rating flow that LeetCode pages give you.

The second is if your problem list is small and your forgetting is not the issue. The extension's value comes from having enough rated problems that the retention model has something to schedule. A handful of problems seen once does not need an FSRS queue, and the setup cost, rating every problem you solve, is real friction.

The third is if you are on Firefox. Compatibility is listed as pending, and the Edge store listing is marked as not restored, so the distribution channels are narrower than the feature set suggests.

There is also a design constraint that is easy to miss. The rating is the input to everything, and a rating that is not honest degrades the schedule without any visible error. If you rate a problem as solid because you solved it in twenty minutes and then never revisit it, the algorithm will schedule it far out and you will lose it. The same applies in reverse. This is a property of every spaced repetition system, but the extension makes it a daily habit rather than a weekly one.

On maintenance and licence, the picture is mixed. The last push was on 2026-04-06 and the most recent release is v0.1.8 from 2026-03-29, so the repository has not been touched for several months. The repository licence is MIT, while the licence field in package.json reads ISC, so the two records in the project disagree and the LICENSE file is the one to check. The project also ships a PRIVACY POLICY.md file at the top level, which is the document to read before you sync your review history to a third party storage service.

Editorial conclusion

Adopt Leetcode Mastery Scheduler if you want your LeetCode practice to follow a memory curve rather than a queue you work through by mood, and you are willing to rate every problem you solve. Do not adopt it if you need it to track problems outside LeetCode today, because support for other sites such as Luogu is still listed as pending, and note that the Chrome sync route has a stated memory ceiling of roughly 300 problems. Verify first that the built package works on the browser you use, since the Edge store listing is marked as not restored and Firefox compatibility is listed as pending.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. xiaohajiayou/Leetcode-Mastery-Scheduler on GitHub