PRAXIS
A gamified, industry-generic way to actually practice product management. A six-level path from your first PM job to VP where you build mastery by doing the reps: drills, written artifacts, stakeholder roleplay, and a simulation that teaches itself. Runs in the browser, no signup.
PRAXIS is a gamified, industry-generic way to actually practice product management. Instead of reading about PM, you do reps: a six-level path that runs from your first PM job up to VP, where every skill is something you do, a drill, a written deliverable, a hard conversation, a full product run, not something you watch. It's built to teach by doing, and to work for a PM in any industry, not just the one it was first prototyped in.
The idea: skill is reps, not reading
PM skill is hard to practice. You can read about prioritization or jobs-to-be-done, but reading isn't reps. PRAXIS turns the core methods into a practice loop: short, retrieval-based reps with immediate feedback and mastery you build over time, the way a language app makes you use the words instead of studying them. And the method is the transferable asset: the same RICE or JTBD drill holds whether you're shipping a marketplace, a dev tool, or a fintech product, so the curriculum is industry-generic by design, with the domain as a swappable flavour rather than the point.
A path of real PM reps, not videos
The path is laid out like a career rather than a syllabus: six levels from Foundations up through Senior, then a fork to Staff and Principal on the IC side or Director and VP on the management side, all built on one spine of PM competencies across execution, insight, strategy, and influence. What makes it practice instead of a course is that every skill is a rep with immediate feedback, in the shapes the job actually tests you in:
- Drills on the real methods: RICE, MoSCoW, Kano, cost of delay, jobs-to-be-done, pre-mortems, PR-FAQs. You make the call, and the app tells you straight away what your answer revealed and why.
- Written artifacts. You draft the deliverables a PM is judged on, a one-page PRD, a strategy memo, an experiment plan, a north-star tree, a positioning statement, and get scored against a rubric.
- Stakeholder roleplay. An in-character counterpart pushes back, a skeptical VP, an engineering lead, a churning customer, and you practice holding your position without burning the relationship.
- A judgment deck. Spaced-repetition decision cards that resurface on a schedule, so the calls you got wrong come back around until they stick.
Progress is mastery you've demonstrated, not boxes you've ticked. A level certifies only once you've shown the skill, and an adaptive test-out lets an experienced PM skip what they can already prove. Seven specialization tracks sit beside the ladder for going deep on a domain like growth, monetization, or AI and ML, once the core reps are behind you.
The design call: reward competence, not streaks
The lazy way to gamify is points, badges, and a guilt-trip streak, and the research on these tools is blunt that they optimize for volume (speed-running the easy lessons) over actual learning. So PRAXIS scores demonstrated competence, frames the streak as flexible "consistency" instead of a daily guilt mechanic, and keeps progress measured against your past self rather than a leaderboard. It's gamified through substance (judgment and mastery), not toys. Same instinct as designing any control that should reward the right behaviour, not the most activity.
The capstone: a simulation that teaches itself
The hardest thing to build was a product simulation a newcomer can play without a manual, and it grew from one capstone into a ladder of five. You run a product across several sprints: pull work from a backlog against a capacity budget you can't fully fund, ship it, and watch revenue, customers, team health, and tech debt react, with events that force real trade-offs. The first run is a gentle tutorial; the harder rungs unlock as you certify each level and tighten the screws, a turnaround, a zero-to-one, a scaling crunch, a regulated launch, so the simulation keeps pace with the judgment you've built. Three rules make it self-teaching:
- The first sprint is the tutorial: one mechanic revealed at the moment you first need it, not a wall of rules up front.
- Capacity is an honest range, with its reasons shown: "11-17 points, because a teammate is onboarding and tech debt is climbing." The core tension (you can't build everything) stays visible, not hidden behind a dice roll.
- Every number that moves comes with a plain-language because: "team morale fell because you committed every point with no slack." You learn the system by watching cause meet effect, not by reading docs.
Under the hood: a deterministic engine as the source of truth
The whole simulation runs on a pure, deterministic engine: a reducer over a seeded random-number generator, fully unit-tested, with no UI or industry coupling. Every screen drives that engine through explicit actions and renders from its state; the UI never recomputes the rules. The same engine drives every rung of the ladder, because each scenario is an industry-neutral structure (the ids, efforts, and effects the rules run on) plus a display pack per industry, so switching from SaaS to healthcare changes every label on screen and not a single number underneath. That separation is why a turn is instant, why a run is perfectly replayable, and why the same engine can power both a thirty-second drill and the full capstone.
The worst-day question
Two of the practice modes lean on a model: grading your written artifacts, and playing the other side of a roleplay. That's a model call sitting behind a public, no-signup button, which is a cost-risk surface the moment someone points a script at it. So the first question I asked was the risk-desk one: what does this do on its worst day? The answer had to be a system, not a hope. Every model route is rate-limited per client, capped on tokens per call, and held to a turn limit the client can't reset, all of it behind a hard global daily ceiling. And when the model isn't reachable, or there's no key at all, the feature degrades to a calm "saved as a draft" rather than failing or running up a bill. The capacity tension at the heart of the simulation is that same risk-thinking made playable: you can't fund everything, so you design for the trade-off, not the happy path.
What broke
Every new player arrived twelve days in. While building the progression UI I seeded the store to match a design mockup: Unit 1 fully mastered, a 12-day streak, yesterday marked active. Great for screenshots. Then it shipped, and the seed became every real player's starting state. Someone opening PRAXIS for the first time saw a history they did not have, in a product whose entire pitch is that progress means mastery you actually demonstrated.
A deterministic engine makes this sting more, not less. I had been careful about seeding the simulation's randomness so replays are reproducible, and then casually seeded the player's life. The fix was a fresh, empty seed and a storage key bump to force migration for anyone who had touched the fake state. The lesson stuck: initial conditions are product decisions, and demo state is a liability the moment it can reach a user. Now anything seeded for a mockup lives behind a flag that cannot ship on.