game-devportfolioeducation

Game Design 101: Tim Cain’s 9 Quest Types and How to Add Them to Your Portfolio

UUnknown

2026-03-10

11 min read

Turn Tim Cain’s nine quest types into 1–6 week portfolio projects with playable demos, resume bullets, and templates recruiters love.

Hook: Build portfolio pieces that actually get interviews — not just screenshots

Students and entry-level designers: you have limited time and a shrinking attention span from recruiters. The fastest way to stand out in 2026 is to ship small, verifiable systems that show you understand how quests work, scale, and fit into RPGs. Tim Cain — co-creator of Fallout — boiled RPG quests down to nine essential types. This article turns each of those types into a practical mini-project, a one-paragraph resume line, and a portfolio template you can implement in 1–6 weeks using modern tools like Unity, Godot, Twine, and AI-assisted content pipelines.

Why Cain’s nine quest types matter for students in 2026

Game hiring in 2026 favors demonstrable systems over conceptual essays. Recruiters want to click a playable demo, inspect a GitHub repo, and read a concise design doc that proves intentional decisions. In late 2025 and early 2026 we’ve seen three hiring trends that make Cain’s taxonomy useful:

Short playable loops — studios prioritize 5–10 minute demos to evaluate design thinking quickly.
AI-assisted content pipelines — procedural dialogue and quest scaffolds are common; employers expect designers to control and refine AI outputs.
Systems-first hiring — employers look for candidates who can design modular quests that are data-driven and testable.

"More of one thing means less of another" — Tim Cain. This is a design lens: each quest type trades off time, complexity, and player investment.

How to use this guide

For each of Cain’s nine quest types below you’ll get:

a concise definition and the recruitment value,
a mini-project idea with scope, tech stack, and estimated time,
a one-line resume bullet optimized for ATS and recruiters, and
a portfolio presentation template (title, elevator, assets to include).

Cain’s Nine Quest Types — mini-projects and portfolio-ready artifacts

1. Fetch / Collection

What it is: Player collects items or resources that trigger progression or rewards. Great for teaching economy design, balancing risk vs reward, and inventory UI.

Mini-project: Build a 5–10 minute demo where players collect 10 items spread across a small map with varied spawn rules (static, respawn timers, RNG). Add a simple economy: collected items convert to currency or crafting materials.

Tools: Unity (C#) or Godot (GDScript), simple tilemap, GitHub repo.
Deliverables: playable WebGL/HTML build, item spawn script (200–400 LOC), design doc (1 page), metrics dashboard (collect counts).
Time: 1–3 weeks.

Resume bullet: Designed and implemented a modular item-spawn system for a 10-item collection quest; reduced spawn bug rate by iterating spawn rules and playtesting (Unity, C#).

Portfolio template: Title: "Scavenger Run — Collection Quest System". Elevator: 45–90 sec demo video + link to build. Include item spreadsheet, spawn code snippet, playtest notes and basic telemetry (average completion time).

2. Kill / Combat Objective

What it is: Remove an enemy or a set of enemies. Demonstrates combat pacing, AI encounter design, and reward balancing.

Mini-project: Create a short arena encounter with three enemy types and a scaling spawn wave. Show how difficulty curves by adjusting health, damage, and spawn frequency. Add a post-combat reward chest that uses the collection system above.

Tools: Unity or Godot, simple AI behavior tree or state machine, FMOD or basic audio cues.
Deliverables: 6–8 min playable demo, AI behavior graph screenshot, tunable parameters in a JSON or ScriptableObject file.
Time: 2–4 weeks.

Resume bullet: Developed encounter balancing system with three enemy archetypes and wave-based spawner; tuned via data-driven parameters to achieve target playtime and difficulty.

Portfolio template: Title: "Wavebreaker — Scalable Combat Encounters". Include annotated encounter map, tunable parameter file, short analytics (time-to-kill, player deaths by wave) and a 60s highlight clip.

3. Escort / Protection

What it is: Safeguard an NPC or object. Focuses on pathfinding, companion behavior, and failure states.

Mini-project: Build a short escort mission where the NPC has a simple goal-seeking AI and reacts to hazards. Implement fail, recovery, and checkpoint systems to make it player-friendly.

Tools: Godot or Unity NavMesh, simple FSM for NPC, visual debugging tools.
Deliverables: demo, NPC behavior DAG, test cases that show edge conditions (NPC stuck, attacked).
Time: 2–4 weeks.

Resume bullet: Implemented resilient escort AI with checkpoint recovery and hazard reactions, lowering completion frustration in playtests by 40%.

Portfolio template: Title: "Safe Passage — Escort AI Demo". Show video of failure recovery, include decision tree and unit tests, plus a short postmortem about balancing frustration vs challenge.

4. Delivery / Travel

What it is: Move something or someone from point A to B. Highlights route design, minimap UX, and pacing.

Mini-project: Design a delivery quest that offers multiple routes (safe/long, risky/short) with branching rewards. Implement a simple timer or dynamic obstacle to force decision-making.

Tools: Unity/Godot, basic waypoint system, UI for minimap and route choice.
Deliverables: playable build, route decision log, a simple branching reward table.
Time: 1–3 weeks.

Resume bullet: Created branching route system for delivery quest enabling player choice between risk/reward options; documented trade-offs in a one-page design brief.

Portfolio template: Title: "Courier’s Choice — Route Branching Demo". Include route map overlays, reward matrices, and a downloadable JSON of route nodes.

5. Puzzle / Logic

What it is: Solve a non-combat challenge. Emphasizes player guidance, discoverability, and satisfying reveal.

Mini-project: Ship a 3-room puzzle sequence with clues tied to environmental storytelling. Add an optional hint system that escalates to avoid player frustration.

Tools: Twine for narrative puzzles, or Unity/Godot for spatial puzzles, plus simple state tracking.
Deliverables: playable demo, hint system algorithm, and UX rationale.
Time: 1–2 weeks.

Resume bullet: Designed and implemented a 3-stage environmental puzzle and hint escalation system; improved completion rate in playtests by 25%.

Portfolio template: Title: "The Three Sigils — Environmental Puzzle". Include flowchart, hinting algorithm, and short dev commentary on readability and telegraphing.

6. Investigation / Clue-based

What it is: Gather evidence and deduce answers; great for narrative design and branching outcomes.

Mini-project: Construct an investigation quest with 4–6 clues that can be combined in different ways to produce multiple endings. Integrate a simple dialogue tree and a deduction notebook UI.

Tools: Ink or Yarn Spinner for dialogue; Unity/Twine for notebook UI.
Deliverables: playable demo, dialogue snippets, and state machine showing how clues map to outcomes.
Time: 2–4 weeks.

Resume bullet: Built an evidence-based investigation system with branching conclusions and a UI notebook; authored 600+ lines of interactive dialogue (Ink/Yarn Spinner).

Portfolio template: Title: "Echoes of the Market — Detective Quest". Provide playthrough videos for each outcome, downloadable dialogue file, and a one-page logic map.

7. Choice / Moral Decision

What it is: Player choices change narrative or systems. Employers look for designers who can show clear causality between decision and consequence.

Mini-project: Implement a short moral dilemma with at least two distinct outcomes and visible system feedback (reputation, town reaction). Use telemetry to show how different players chose in playtests.

Tools: Any engine with state persistence; lightweight analytics (PlayFab, custom logs).
Deliverables: playable demo, state-change diagram, anonymized choice statistics from testers.
Time: 2–4 weeks.

Resume bullet: Designed a branching moral-choice system with persistent reputation state and telemetry analysis of player decisions (n=50 playtests).

Portfolio template: Title: "Crossroads — Moral Choice Demo". Show decision tree, outcome videos, and data showing distribution of player choices.

8. Multi-stage / Chain Quest

What it is: A linked series of objectives that form a narrative arc. This demonstrates pacing, checkpointing, and state persistence across sessions.

Mini-project: Create a 3-stage quest that mixes a collection, a combat encounter, and a puzzle. Showcase save/load persistence and transitions with minimal bugs.

Tools: Unity/Godot, basic persistent state system, scene management.
Deliverables: demo with clear stage transitions, quest state JSON, and a short QA checklist documenting edge cases.
Time: 3–6 weeks.

Resume bullet: Implemented a persistent 3-stage quest system with scene transitions and fail-safe checkpointing; reduced state-related bugs during QA by applying a checklist-driven approach.

Portfolio template: Title: "The Long Road — Chain Quest Demo". Include state JSON, screenshots of save files, and a short postmortem describing tradeoffs.

9. Emergent / World Event

What it is: Player-triggered or time-based events that create unique situations (ambushes, dynamic spawns). Great for systems design and replayability.

Mini-project: Build a small world simulation where random events (e.g., bandit raids) spawn based on world state (economy, time of day). Make events affect NPC behavior and available quests.

Tools: Lightweight simulation in Unity/Godot; data-driven event table; optional serverless logs to show event frequency.
Deliverables: demo, event-rule table (CSV/JSON), sample logs showing emergent outcomes.
Time: 3–6 weeks.

Resume bullet: Created an emergent event system that spawned world events based on economic state and time; documented emergent case studies and telemetry.

Portfolio template: Title: "When the Market Burns — Emergent Event System". Offer CSV event rules, video of emergent scenarios, and a short analysis of surprising outcomes.

Design templates & quick-apply features (ready-to-use in your portfolio)

Turn each mini-project into a recruiter-friendly package using these templates and quick-apply features:

One-page quest design doc template — Purpose, stakes, flowchart, tunables, edge cases, QA checklist.
GitHub README template — Elevator summary, tech stack, run instructions (WebGL link), curated files to inspect (design doc, core scripts, dialogue files).
Playable build + 60s highlight clip — Host on itch.io or GitHub Pages; include a 60–90s highlight clip for recruiters who preview before playing.
Resume bullet generator — Fill in: [Action verb] + [system] + [impact metric] + [tools]. Example: "Implemented a modular NPC escort AI, reducing stuck conditions by 60%, using Godot and NavMesh."
Quest JSON / template — Provide a small schema showing how to wire objectives, triggers, rewards. Recruiters appreciate readable data-driven designs.

Advanced strategies — what elite candidates do in 2026

To go from a good portfolio to a recruiter’s shortlist, add these advanced touches:

Telemetry snapshots — even simple logs (completion time, fail rates) show you understand live ops and iteration.
AI-assisted content + human curation — show prompt examples and edits when you used generative models for dialog or quest scaffolding; document your editorial process.
Data-driven tunables — expose spawn rates, health, and reward tables as editable files and show how you tuned them from playtest data.
Modular systems — structure your code so a studio engineer can see reuse potential (ScriptableObjects, Godot scenes, or JSON-configured behaviors).
Cross-platform proof — provide a WebGL build plus Windows executable or video proof for consoles if possible; portability matters.

Checklist before you publish a portfolio quest

Playable demo (hosted) + 60s highlight video.
One-page design doc + flowchart.
Code link with clear README and annotated core files.
Resume-ready bullet and 1-sentence elevator summary.
Telemetry summary and playtest notes (n ≥ 10 testers recommended).
Exported quest JSON or data schema for quick inspection.

Quick portfolio copy templates (use these verbatim)

Use these short texts in your portfolio entry to save time and be recruiter-friendly:

Elevator (1 sentence): "Playable 8-minute demo showcasing a data-driven kill-collection quest with modular spawn rules and playtest-backed tuning (Unity, C#)."
Resume line (one bullet): "Designed and shipped a data-driven collection/kill quest; authored spawn & reward systems and ran 30 playtests to tune difficulty (Unity, C#)."
What to inspect (two bullets): "Open /Design/QuestDoc.pdf for the flowchart. Check /Code/Spawner.cs for the spawn logic."

Final notes and 2026 hiring tips

By 2026, interviewers expect candidates to show more than ideas — they want evidence. Cain’s nine quest types are a practical rubric: you can quickly demonstrate systems thinking by shipping focused, playable examples that expose design decisions and trade-offs. Keep projects short, data-driven, and modular so recruiters can quickly evaluate both your design sense and engineering hygiene.

Actionable next steps (start today)

Pick one quest type you haven’t shown before.
Set a 4-week scope: week 1 design, week 2 prototype, week 3 polish + telemetry, week 4 publish + write docs.
Use the one-page design doc template and the resume bullet generator above.
Publish on itch.io + link in your GitHub README; share a 60s highlight in your application emails.

Call to action

Ready to turn Cain’s nine quest types into portfolio wins? Download our free one-page quest design doc template and resume bullet generator at quickjobslist.com/templates, build a mini-project this month, and tag it with #GameDesign101 when you apply — hiring managers are searching for it in 2026. Ship something small, ship it often, and make every artifact recruiter-friendly.

Unknown

Contributor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.