PRAXIS

PRAXIS is a gamified, industry-generic way to actually practice product management. Instead of reading about PM, you do reps: a structured path of short, interactive drills (discovery, prioritization, metrics, strategy) with a full product simulation as the capstone. 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 drills 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 learning path of real PM drills

The path is laid out like a curriculum (discovery, prioritization, metrics, execution, strategy, experimentation, communication and risk), and each skill is a focused, interactive drill on a real method: RICE, MoSCoW, Kano, jobs-to-be-done, pre-mortems, PR-FAQs. You make the call, and the app tells you immediately what your answer revealed and why. Progress is mastery you've demonstrated, not boxes you've ticked.

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. 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. 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. 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

The two AI touches (optional grading on the open-ended drills, and an end-of-run retrospective) sit off the critical path: the game is fully playable without them, and they fail gracefully when the model isn't reachable. And an uncapped model call behind a public, no-signup button is a cost-risk surface, so the AI stays off the open endpoint until it's properly rate-limited. It's the risk-desk reflex applied to a portfolio project: what does this do on its worst day, when someone points a script at the public URL? The capacity tension at the heart of the sim is that same risk-thinking made playable: you can't fund everything, so you design for the trade-off, not the happy path.