Building a subscription cancellation game: 45 levels of hostile UX

A subscription cancellation game has one obvious problem: the joke can become repetitive long before the cancellation is complete. There are only so many times a button can move, shrink or ask "Are you sure?" before the player understands the pattern. If every level is another deceptive form, a 50-level game becomes one level repeated 50 times.

That has been the central design challenge behind Cancel My Subscription. The player is trying to leave ZenFlix+, a fictional streaming service whose retention department treats a simple cancellation request as an administrative emergency. The objective never changes. The method of resistance has to change constantly.

Our second development log ended at Level 23 with moving targets, cloned controls and a support chat that would not take no for an answer. Since then, the development build has reached Level 45. This update explains what changed, why several seemingly good ideas were rebuilt, and how the later levels became less like separate jokes and more like one connected system.

What kind of game is Cancel My Subscription?

Cancel My Subscription is a free, two-dimensional browser game about navigating an intentionally overcomplicated cancellation flow. It mixes interface puzzles, timing, memory, observation, drawing, physics and small arcade challenges. Each level represents another department or requirement inside the same fictional company.

It is satire, but it is not a simulation of one real service. ZenFlix+ borrows the tone of familiar subscription interfaces: cheerful retention offers, neutral legal wording, reassuring progress bars and confirmation screens that reveal less than they appear to. The comedy works best when the interface almost seems plausible. Random nonsense breaks the fiction; polite bureaucracy that has gone one step too far strengthens it.

The game is planned as 50 levels. Each stage must work with a mouse and on a touchscreen, fit inside the shared game frame, and be understandable without a paragraph explaining the joke. Those constraints shape every mechanic more than the number 50 does.

What changed after Level 23?

The early game teaches the basic language of cancellation friction. The player clicks, types, reads, unticks, searches and confirms. Later levels cannot simply make those tasks longer. They need to combine information, create pressure and make earlier decisions feel consequential without requiring a manual.

We divided the next stretch into three broad phases. Levels 24–30 turn ordinary interface friction into physical systems. Levels 31–40 make several requirements interact at once. Levels 41–45 begin the final gauntlet, where the player's previous records are assembled, protected and finally submitted.

The result is a change in rhythm. A difficult precision challenge can be followed by a slower observation task. A memory level can be followed by a tactile machine. The player is always cancelling a subscription, but they are not always exercising the same skill.

Levels 24–30: when hostile interfaces became physical

Level 24 begins as a document review. The player approves tracked changes while ZenAssist, an unwanted automated collaborator, edits the cancellation reason back toward retention. A final save conflict asks which version should survive. The important change is that the obstruction is visible. The player can see the cursor arrive, see the text change and understand what must be restored.

Level 25 turns a progress bar into a hand-cranked machine. Three automated checks each stop at 99 percent, leaving the player to generate the last percent manually. Level 26 fills the workspace with draggable system notices and retention windows. Closing the wrong type duplicates the clutter instead of quietly marking an answer incorrect.

The next three levels focus on pressure and interpretation. One asks the player to hold a resisting cancellation control for five uninterrupted seconds. Another uses a certainty slider whose approved range moves, narrows and drifts. A consent processor then presents nested yes-or-no statements that must all resolve to the cancellation continuing.

Level 30 changes pace again. CCTV feeds show envelopes moving through an office, and the player must identify every camera crossed by the red cancellation envelope while ignoring retention-coloured decoys. It is still a document-routing joke, but the interaction is now observation rather than form completion.

This phase taught us that absurdity becomes more enjoyable when it has a visible cause and effect. A bar that simply waits is irritating. A machine that visibly refuses to finish until the player turns a crank is irritating in a way the player can act upon.

Levels 31–40: requirements begin to stack

By Level 31, individual controls are no longer enough. A moving typewriter carriage allows each letter of CANCEL only inside a narrow authorization window. Level 32 asks the player to synchronize a reason, date and declaration before passing the complete record through one scan. Level 33 turns workflow order into a physical puzzle with magnetic cards: record the declaration too early and a later action clears the signature.

These levels are harder because their rules interact, not because the buttons are smaller. The player has to understand a system and then operate it. That distinction matters. Tiny controls punish the device a person owns. Interacting timers, sequences and states test the player while remaining usable on a phone.

The middle of this phase introduces deliberate time pressure. A final-review phone call wastes most of its own connection window before asking a direct question. A moving Cancel carriage repeatedly swaps places with a retention offer while the player keeps holding it. A phrase-building terminal scores every selected statement for retention risk, so the final record must stay below the allowed threshold.

Memory then becomes part of the cancellation record. Level 37 asks the player to repeat increasingly long visual and tonal routing sequences. Mistakes raise a persistent retention score. Level 38 presents an account dossier and a polygraph-style trace; answers must remain consistent with the visible facts. Level 39 is a subjective CAPTCHA about selecting squares that express regret. Level 40 makes declaration, reason, date and retention valid at the same time before authorization expires.

This is where the project started to feel like a complete game rather than a collection of sketches. Information introduced in one panel affects another. A mistake changes pressure later in the sequence. The player is learning ZenFlix+'s internal logic, however unreasonable that logic may be.

Levels 41–45: the final gauntlet begins

Level 41 gathers six earlier records into physical cartridges. The player docks each module into its matching bay and runs a staged system boot. Level 42 exposes the live dashboard behind those modules: three record drums, a certainty band and a retention score must all remain valid together before the final commit becomes available.

Level 43 then gives ZenAssist remote access to that approved dashboard. Its cursor visibly travels to a field before changing the value. The player restores four sabotages, waits for a clean moment, disconnects remote support and holds the record stable long enough to submit. The system cheats, but it announces its movement and obeys a cap on simultaneous damage. The challenge is defensive attention, not guessing what changed off-screen.

Level 44 makes obstruction literal. A mounted completion survey covers the real submit control. Four corner clamps must be released before the cover can travel up its storage rails. The visual design communicates the problem before text does: something has been bolted over the action the player needs.

Level 45 presents what looks like success. Confetti fills the screen. A large confirmation says the cancellation succeeded. The official receipt, however, contains a security strip. Moving a magnifying lens over it reveals that the account was only paused and billing will resume. The player must reject the celebration and challenge the false outcome.

That false-success screen is an important milestone. Earlier levels put resistance before submission. Level 45 asks whether the player is still reading after the interface tells them to relax. The mechanic is simple observation, but its placement gives it weight.

How do you keep 45 browser-game levels from feeling repetitive?

We use a practical rule: every level needs one primary verb. The player may click controls around it, but the identity of the stage should be expressible as crank, sort, hold, balance, remember, route, drag, inspect or defend. If two neighbouring concepts have the same verb and the same pressure, one of them is probably redundant.

Visual setting is not enough by itself. A courtroom and a mailroom can still be the same multiple-choice quiz wearing different artwork. We look at the actual decision loop: what the player observes, what action changes the state, how failure is communicated and what improves on the next attempt.

Pacing provides the second layer of variety. Not every level should be a puzzle, and not every puzzle should be difficult in the same way. The long document sequence is deliberately obnoxious. The slot machine is timing-based. Pachinko introduces physical uncertainty. The courtroom tests memory. The calendar asks the player to calculate and then physically tear to a date. Short spectacle levels create breathing room between systems that demand concentration.

Why the game aims for absurdity, not randomness

There is a difference between a surprising rule and an arbitrary one. A player can accept that a cancellation office requires a notarised date to the current minute because it extends a recognisable administrative demand to an absurd extreme. A random button that changes the rule without warning is harder to read as satire; it is simply unreliable.

We rewrote a significant amount of interface copy for this reason. The funniest wording often sounds almost official. Retention options should read like permissions to keep the subscription, not like obvious joke answers. Legal clauses should each say something distinct. A fake success receipt should contain a plausible reference number and service-action language before the hidden status reveals the trick.

Cohesion also makes difficult levels fairer. If the fictional company consistently uses the same terms for cancellation, pause, renewal and retention, the player can reason about later screens. The writing becomes part of the game's rule set rather than decoration around it.

How we make intentional frustration fair

The game is supposed to resist the player, but it should not hide whether an input registered. Buttons depress. Machines move. Incorrect sections pulse after submission. Audio confirms a peg collision or a failed drop. A visible cursor shows which field ZenAssist is about to edit. These responses do not reveal the solution; they confirm that the system heard the player.

Failure feedback stays close to the type of problem. A generic submission error is appropriate when the player needs to re-read a document and find a retention consent they accidentally ticked. A red boundary around the checkbox section can identify the area without highlighting the exact answer. A timing challenge should show that the input was early or late through movement, not expose the correct millisecond.

Recovery matters as much as failure. The player should be able to retry a statement without repeating an entire hearing unless restarting is an intentional escape hatch. A missed slot reel can be spun again immediately. A signature comparison gradually offers a trace after repeated failed attempts so an imperfect motor task does not permanently block progress.

Why mobile support changes the mechanic itself

Responsive browser-game design is not only about stacking columns. The interaction must survive a different hand, screen and field of view. A desktop scale can place counterweights beside the weighing platform. On mobile, a bottom drawer keeps both the available objects and the result in view. A wide whiteboard needs a different internal composition rather than shrinking every label until it becomes unreadable.

Drag interactions use Pointer Events so the same logic accepts mouse, pen and touch. Draggable objects are clamped to their intended work area. This prevents receipts, calendar pages and weights from disappearing beyond the screen. Where dragging is flavour rather than the core test, a tap fallback prevents a difficult gesture from becoming a hard block.

We check normal desktop, a common phone width and a narrow 320-pixel viewport. The test is not merely whether horizontal overflow equals zero. The player must see the action and its consequence together, controls must remain large enough to tap, and labels must not collide with animated art. A layout can pass a width measurement and still fail as a game.

What custom art and sound add to a web game

Custom artwork gives the cancellation process physical places: a courtroom, an office whiteboard, a calendar desk, a slot machine, a pachinko cabinet and a document-processing station. We use generated or prepared bitmap assets for objects and environments that benefit from texture, then keep live labels and controls in HTML wherever possible.

That separation improves responsiveness and clarity. Text baked into an image cannot reflow, may be malformed and does not behave like an accessible control. Artwork can provide the machine; the browser provides the button, status and keyboard semantics. Compressed WebP files keep the visual identity without making every scene unnecessarily heavy.

Sound follows the same rule as animation: it supports the action rather than carrying essential information. Mechanical levels benefit from a click, clunk, reel stop or pachinko impact. Success sounds make a completed sequence feel final. The visual state still communicates the same outcome when the device is muted.

What we rebuilt instead of accepting the first draft

Several levels changed direction after the first playable version. A printer concept became too complicated to read and was replaced by the cancellation slot machine. A document stack looked decorative rather than interactive, so the level focused on scroll, notarisation and a real drawn signature. An old-fashioned balance scale did not fit the visual world, so it became a modern digital workbench with counterweights that remain visible on the platform.

These were not cosmetic revisions. Each rebuild clarified the primary verb. The best-looking interface cannot rescue a mechanic whose next action is unclear. Conversely, an obvious action can still feel unfinished if objects jump, duplicate, drift outside the board or animate without enough physical weight.

Our process is therefore deliberately iterative: establish the rule, play it, inspect the desktop composition, test mobile, tune feedback, then replay from the beginning of the level. A direct link to any level speeds up development, but the complete run remains necessary because saved state, scroll position and earlier records can change what happens later.

What remains before Level 50?

Five stages remain in the current plan. They need to complete the cancellation without becoming five versions of a final confirmation screen. The intended pressure is convergence: logical confirmation, exact wording, distraction, deliberately confusing abort language and the final certificate all need distinct interactions while feeling like the same last administrative push.

Finishing Level 50 will not finish the work. The full game then needs an uninterrupted Levels 1–50 audit on desktop and mobile. That pass will check old assumptions, persistent signature data, timing, audio, viewport changes, retries and every transition into the next scene. A level-based browser game is only complete when the route between the levels is as reliable as the levels themselves.

After that, the public build can become the real measure. Completion data will show where players leave, not just where the development team expects difficulty. Feedback will reveal which jokes read clearly without context and which controls need another pass. The goal is still the same one we began with: make a short browser session feel surprising, specific and worth sharing.

The lesson at Level 45

The hardest part of building a long browser game is not producing more content. It is preserving the player's trust while the game deliberately gets in their way. The rules may be unreasonable, but the input must work. The company may mislead the player, but the game must provide enough evidence to catch it. The task may be absurd, but it should belong to the world.

Forty-five levels have made that boundary much clearer. Cancel My Subscription works when each stage is a new physical or mental expression of the same hostile process. It stops working when difficulty comes from cramped controls, invisible changes or wording that is random for its own sake.

For the technical side of the project, read how we structure the game with HTML, CSS and JavaScript. For a closer look at touch controls and responsive mechanics, see how we make the browser game work on mobile.