From Quest Types to Portfolio Pieces: Using Tim Cain’s RPG Framework to Showcase Game Design Skills

Hook: Your portfolio isn't getting interviews—because it looks like every other game designer's

If your reels and PDF design documents read like a blur of systems and buzzwords, recruiters and leads in 2026 will skip them. Hiring teams don’t just want “experience”; they want evidence: playable prototypes, clear design decisions, and measurable results. The good news? Tim Cain’s nine quest archetypes give you a compact, recruiter-friendly framework to showcase variety, depth, and systems thinking across nine distinct portfolio entries.

Quick prescription (most important first)

Turn each of Cain’s nine quest archetypes into a dedicated portfolio case study. For each case study include:

• Playable prototype (WebGL / Itch / build link or short video)
• 1–2 page design brief highlighting goals, failure conditions and player loop
• Annotated design document (mechanics, pacing, encounters, dialogue trees or procedural rules)
• Playmetrics capturing engagement, completion, choice distribution and outlier sessions
• Short case study (3–5 lessons learned + what you’d change with more time)

“More of one thing means less of another.” — Tim Cain (as quoted in late-2025 discussions)

That quote is a hiring signal: show you can scope and trade off. Recruiters want designers who can ship under constraints and justify scope.

Cain’s nine quest archetypes (and how to turn each into portfolio gold)

Below I map nine archetypes (the ones popularised by Tim Cain in late-2025 coverage) into portfolio entries. Use each as a mini-case study template you can adapt to your strengths and the studio you target.

1. Fetch / Delivery Quest

Design focus: routing, item economy, pacing and risk vs reward.

• Prototype scope: one or two delivery nodes, player inventory toggle, a timer or hazard mechanic.
• Design doc highlights: item weight and inventory rules, risk modifiers (guards, weather), economy sinks, quest gating.
• Playmetrics to collect: time-to-complete, abandon rate, route variance, gold/items per minute.
• Portfolio presentation: route heatmaps, a short clip of player choices, annotated screenshot of balancing spreadsheets.

2. Kill / Combat Quest

Design focus: encounter pacing, player agency, combat feel, risk management.

• Prototype scope: one encounter arena, 2-3 enemy types, player modifiers (stealth, DPS, shield).
• Design doc highlights: encounter flowchart, telegraphing rules, enemy AI states, difficulty tuning knobs.
• Playmetrics to collect: DPS curve, damage taken distributions, success per approach (stealth vs direct), time-to-kill.
• Portfolio presentation: video highlight, combat telemetry dashboard, postmortem explaining tuning decisions.

3. Escort / Protect Quest

Design focus: AI reliability, player responsibility, escort pacing and emotional stake.

• Prototype scope: escort NPC with a few scripted behaviors, split path choices and hazards.
• Design doc highlights: NPC state machine, failure conditions, visual/audio cues, player intervention mechanics.
• Playmetrics to collect: escort survival rate, number of manual saves, player interventions per minute.
• Portfolio presentation: annotated debug log of AI failures and fixes, short tests showing reliability improvements.

4. Exploration / Discovery Quest

Design focus: curiosity loops, environmental storytelling, reward sparsity.

• Prototype scope: small explorable map with 4–6 points of interest and non-obvious rewards.
• Design doc highlights: environmental cues, breadcrumbing systems, discovery scaling (first vs repeat players).
• Playmetrics to collect: POI visitation order, time between POIs, percent of map uncovered, unique discovery rate.
• Portfolio presentation: discovery flow visualizations, player quotes from playtests, annotated screenshots of environmental storytelling beats.

5. Puzzle / Obstacle Quest

Design focus: cognitive load, affordances, rule clarity and satisfaction curve.

• Prototype scope: 2–3 interconnected puzzles with escalating rule complexity.
• Design doc highlights: rule set, hint system design, failure modes and graceful exits.
• Playmetrics to collect: hint usage, attempt distribution, solve time variance, path-to-solution heatmap.
• Portfolio presentation: step-by-step solution, video of discovery moments, metrics showing reduced hint usage after tuning.

6. Social / Dialogue Quest

Design focus: branching narrative, meaningful choices, NPC motivations and consistency.

• Prototype scope: short conversation tree with 3–4 branching outcomes affecting at least one variable (reputation, ally).
• Design doc highlights: dialogue table, emotional beats, consequence map, tone guide.
• Playmetrics to collect: choice distribution, branch completion rates, replays to see alternate dialogue paths.
• Portfolio presentation: conversation flow image, sample dialogue lines, metrics on how choices correlated with player retention.

7. Investigation / Mystery Quest

Design focus: clue chaining, inference mechanics, pacing of revelations.

• Prototype scope: 3–4 clues with red herrings and at least two valid solution paths.
• Design doc highlights: clue map, false-solution analysis, evidence weighting system.
• Playmetrics to collect: clue discovery order, false-solve rate, time spent verifying clues.
• Portfolio presentation: annotated clue timeline, player quote highlights, adjustments you made after playtests.

8. Sandbox / Player-Driven Quest

Design focus: affordances, emergent goals, systems that produce player goals.

• Prototype scope: a compact set of interacting systems (economy, combat, crafting) that allow emergent goals.
• Design doc highlights: system interaction map, metrics for emergent behaviours, designed friction points.
• Playmetrics to collect: user-generated goals, time-to-first emergent action, most common emergent sequences.
• Portfolio presentation: short clips of emergent play, diagrams of system interactions, how you tuned for balance.

9. Systemic / Emergent Quest

Design focus: rules that generate content, AI-driven dynamics, deterministic vs stochastic outcomes.

• Prototype scope: a small procedural system (e.g., faction reputation + event generator) that spawns unique quests.
• Design doc highlights: algorithm explanation, sample seeds, debug tools you built.
• Playmetrics to collect: seed diversity, repeatability rates, distribution of generated quest types.
• Portfolio presentation: live demo of seeds, annotated code snippets (or pseudocode), telemetry showing content variety.

What a single case study should include (template)

Use this repeatable structure for each of the nine entries. Keep each case study scannable—hiring teams often spend under a minute per project.

1. One-line summary (what you shipped and why it matters).
2. Role & timeline (your responsibilities and the 1–3 week sprint scope).
3. Design goal(s) and success metrics (what you measured).
4. Prototype link or embedded 60–90 second video.
5. Key mechanics (diagrams/screenshots; keep it to 3–6 focused bullets).
6. Playmetrics (charts and 3–5 KPIs with a sentence explaining why each matters).
7. Challenges & trade-offs (include anything you cut and why).
8. What you’d do next (shows growth mindset).

Playmetrics you must show in 2026

By 2026, studios expect data. Include a small analytics dashboard screenshot or embed a CSV with:

• Completion rate (players who finished the quest / total players)
• Time-to-complete median & quartiles
• Branching distribution (percentage choosing each dialogue or action)
• Drop-off points (exact scene or second where players quit)
• Engagement per session (actions/minute, unique interactions)

Optional but high-impact: A/B test results or simple retention curves after a tweak (e.g., “after tuning enemy telegraphing, completion rose 18%”).

Tools & workflows — practical and modern (2026)

Adopt low-friction pipelines so hiring teams can play and verify quickly.

• Prototyping: Unity WebGL builds (host on Itch or your site), Godot HTML5 exports, or lightweight Phaser demos for web play.
• Versioning & demo hosting: GitHub + Git LFS, Vercel/Netlify for frontend demos, Itch.io for quick access builds.
• Design docs & presentation: Notion or Figma for annotated walkthroughs; export a PDF for ATS-friendly submission.
• Playtesting & telemetry: PlaytestCloud, Unity Analytics, GameAnalytics, or simple Google Analytics events for WebGL prototypes.
• AI-assisted tasks (2026): Use model-assisted design (code generation for prototype scaffolding), narrative branching auto-suggestions, and ML models to analyze play logs for emergent patterns. Always document model use in your case study.

Case study mini-examples (realistic, resume-ready snippets)

Example A — Fetch Quest (Aisha, Junior Designer)

One-line: Built a timed delivery quest prototype to test risk/reward pacing for a city map. Role: solo designer, 2-week build.

Key metrics: completion 62% (±Q1 14 min), median completion 9m, abandonment spike at checkpoint 2 reduced by redesign (from 28% to 10%). Resume-ready bullet:

Designed and shipped a timed delivery prototype (Unity WebGL) that improved checkpoint retention by 18% after two tuning passes—documented in a 2-page postmortem and live telemetry dashboard.

Example B — Social Quest (Marco, Narrative & Systems)

One-line: Developed a short branching conversation that tested moral ambiguity. Role: narrative lead; wrote dialogue table and implemented branching states.

Key metrics: choice A selected 41%, B 34%, C (secret) 25%; replay rate 16% (players replayed to see alternate outcomes). Resume bullet:

Authored and prototyped a 3-branch dialogue system; documented player choice distribution and integrated A/B hinting which increased alternate-path discovery by 12%.

How to write winning resume bullets from these case studies

Recruiters scan for impact. Turn each case study into 1–2 resume bullets using numbers and verbs:

• Verb + scope + measurable outcome + tool: "Designed a 3-encounter combat loop (Unity) that increased average engagement time by 23% after two tuning passes."
• For junior roles, emphasize rapid iteration and learning: "Prototyped an exploration map in 10 days; used playtest feedback to reduce waypoint confusion by 40%."

Advanced strategies & future predictions (why this matters in 2026)

Hiring has shifted. In 2026 studios prefer designers who can:

• Ship measurable prototypes quickly—remote hiring and distributed teams mean recruiters can ask for a link and expect immediate verification.
• Use AI responsibly—with new model disclosure norms, include a short note on how you used AI to speed prototyping or generate NPC dialog.
• Demonstrate live-op thinking—many studios expect designers to think beyond single release and show how systems scale.
• Present telemetry and test results—data-savvy designers rank higher; if you can show a before/after from an A/B, you stand out.

Prediction: By the end of 2026, portfolios that lack playable demos or telemetry will be filtered out faster—employers will use automated pre-screening and expect a demo link on applications.

Common objections & short fixes

“I can’t make playable builds.”

Fix: Ship recorded playthroughs with full telemetry logs and brief interactive prototypes built in Construct or Phaser. Even a video + CSV trumps a static PDF.

“I don’t have time to do nine projects.”

Fix: Do three deep case studies that each cover multiple archetypes—e.g., a sandbox prototype that surfaces exploration + emergent quests; a narrative prototype that demonstrates social + investigation mechanics.

“Recruiters ask for code—I'm a designer.”

Fix: Include pseudocode snippets and annotated designer-facing scripts. Host full code on GitHub but highlight the design-level assets and explain them in plain language.

Checklist before you publish

• Playable demo link works on desktop and mobile (or include a 60–90s video fallback).
• Each case study has at least one KPI and a visualization.
• Design docs are readable (2–4 pages) and include a TL;DR and trade-off statement.
• AI use is disclosed and explained.
• Resume bullets derived from case studies use numbers and tools.

Final notes: scope like Cain suggests—less is more

Tim Cain’s line—“more of one thing means less of another”—is permission and a challenge. Recruiters want designers who can prioritize. Each portfolio entry should show disciplined scoping: what you delivered, why you prioritized it, and how you measured impact. That thinking is often more persuasive than an overly ambitious but unfinished project.

Call to action

Ready to convert Cain’s nine archetypes into a portfolio that gets interviews? Download our free 9-entry portfolio template (includes design doc skeletons, telemetry dashboard examples, and resume bullet generator) or book a 30-minute portfolio review to get personalized edits and ATS-friendly export tips.

Related Reading

• AI Vertical Video and Relationships: How Short-Form Microdramas Can Teach Conflict Skills
• Budget Smarter: Using Google’s Total Campaign Budgets to Run Seasonal Wall of Fame Ads
• Where to Buy Cheap E‑Bikes Without Getting Burned: Import Buyer’s Guide
• Economic Shocks and Security Budgets: How to Prioritize Security During High Inflation
• Open-Source POS: Running a Fast, Secure Linux-Based System in Your Restaurant