Key Takeaways
- Show the game, then explain the design. Gameplay footage or an accessible prototype helps establish what was built. A concise breakdown explains the reasoning behind it.
- Choose projects for the role you're pursuing. Level design, gameplay design, systems design, and narrative design require different kinds of evidence.
- Start with work you can finish. A complete mechanic, level, or short interactive experience is a practical starting point.
- Document changes, not just features. Explain what testing revealed, what changed, and what the designer learned.
- Make the portfolio easy to review. Clear project titles, visible contributions, working links, and concise descriptions help reviewers find what matters.
A game design portfolio is a collection of projects that demonstrates how someone designs interactive experiences. It can include playable games, individual levels, gameplay mechanics, prototypes, design documents, and examples of how feedback changed a project.
The finished game matters. So does the thinking behind it.
For someone pursuing a first game design role, a small, completed project with clear design decisions can offer more useful evidence than an ambitious game that never reached a playable state. A strong portfolio makes it easy to understand what the designer created, what problems they solved, and which parts of the work were their responsibility.
This guide covers what to include, how to choose projects, how to build a portfolio without professional experience, and how to present work for different game design specializations.
What Should a Game Design Portfolio Include?
A game design portfolio should contain selected projects that demonstrate relevant design skills. Each project needs enough context for someone unfamiliar with the game to understand the intended experience and the designer's contribution.
The essential components are:
| Portfolio element | What it demonstrates |
|---|---|
| Playable games or prototypes | The ability to turn an idea into an interactive experience |
| Gameplay videos | How mechanics, encounters, or levels function |
| Design documentation | The reasoning behind mechanics, systems, or player experiences |
| Process evidence | How a project developed from its initial concept |
| Playtesting and iteration | How the designer responds to observations and feedback |
| Individual contribution details | The work completed personally, particularly on team projects |
| Contact information | How a reviewer can reach the designer |
Not every project needs every component. A systems design case study may benefit from a balancing spreadsheet and simulation results. A level design case study may be better served by an annotated layout, gameplay walkthrough, and screenshots of earlier blockouts.
The goal is to select the evidence that makes the design work understandable.
How many projects should a game design portfolio have?
There is no universal project count.
For a first portfolio, two or three well-documented projects can provide a manageable starting point. This is a practical recommendation, not a hiring standard. One substantial project may be enough to begin building a portfolio, but additional work can help demonstrate a wider range of skills or design challenges.
Before adding another project, ask whether it demonstrates something the existing portfolio does not. Three similar levels may show consistency, but a level, a gameplay mechanic, and a playtesting case study could demonstrate different capabilities.
What Do Game Studios Look for in a Game Design Portfolio?
A portfolio needs to show what the designer can actually do.
Epic Games' career guidance recommends presenting strong, complete work that reviewers can access with minimal effort. Its game design guidance also encourages applicants to explain their responsibilities, software, achievements, and lessons learned. Commentated video walkthroughs and playable modules are especially useful for demonstrating interactive design.
These recommendations point to several questions a portfolio should answer.
What was the intended player experience?
A level designer might want players to notice a landmark before choosing a route. A gameplay designer might want a movement mechanic to feel responsive but difficult to master. A systems designer might need progression to remain engaging without requiring repetitive tasks.
The portfolio should state what the design was intended to achieve.
How was the experience created?
Show the relevant implementation. This might be a playable prototype, level layout, ruleset, gameplay system, or interactive narrative.
What decisions did the designer make?
Explain the alternatives considered, the constraints involved, and why one approach was chosen.
What happened when someone played it?
A useful case study shows what testing revealed. It should distinguish observed player behaviour from the designer's interpretation of that behaviour.
What did the individual contribute?
Team projects require precise attribution. Someone who designed encounters and adjusted enemy behaviour should say so rather than imply ownership of the entire game.
The clearest portfolio pages establish these facts without forcing the reviewer to read lengthy development diaries.
How to Build a Game Design Portfolio Step by Step
Step 1: Choose the game design role you want to demonstrate
Start with the kind of work you want to pursue.
Game design includes several specializations. Gameplay designers work on mechanics and interactions. Level designers shape playable spaces and encounters. Systems designers develop connected rules and progression structures. Narrative designers create interactive storytelling experiences.
These areas overlap, especially on smaller teams, but each emphasizes different skills.
A portfolio aimed at level design should not rely primarily on character models. A systems design portfolio needs more than attractive interface mock-ups.
Choosing a direction helps determine which projects deserve the most attention.
Someone still exploring different roles can include varied projects, provided each one has a clear purpose.
Step 2: Select projects that demonstrate a specific skill
Review existing work and identify what each project proves.
A useful starting question is:
What can another designer learn about my abilities by examining this project?
Consider three examples:
- A puzzle prototype: Demonstrates how mechanics teach players to recognize patterns, test solutions, and progress through increasing difficulty.
- A combat encounter: Demonstrates how enemy placement, cover, movement, and timing influence player decisions.
- A progression system: Demonstrates how resources, rewards, and balancing decisions affect player choices.
A project is stronger when the design challenge can be explained clearly.
If existing work is mostly unfinished, select a small part that can be completed and tested. One polished interaction may be easier to assess than a large game containing numerous incomplete systems.
Step 3: Create a playable prototype
A prototype tests whether a design idea works as intended.
It does not need the visual production quality of a commercial release. Early versions often use basic shapes, placeholder assets, and simplified systems.
For example, someone exploring level design could build a short environment with two routes to the same objective. The design problem might be whether players recognize the alternative route and understand the risks associated with each choice.
The prototype should support that question.
Tools depend on the project. Unity, Unreal Engine, Godot, and other game development tools can support different types of interactive work. The best choice is the one that allows the designer to create and test the intended experience within their available time and technical ability.
Step 4: Record the design process
Save evidence while creating the project.
Useful material includes early sketches, level blockouts, mechanic diagrams, gameplay captures, playtest observations, and screenshots of significant changes.
These materials make it possible to explain how the project evolved.
For a level design portfolio, an early blockout might show how the designer established routes and encounters. A later version could demonstrate changes to sightlines, landmarks, or pacing.
For a gameplay system, a table comparing earlier and revised values could make a balancing decision easier to understand.
Not every development step belongs in the final portfolio. Keep the stages that explain important decisions.
Step 5: Test the design with other players
A designer knows what their game is supposed to do. A new player does not.
Testing helps reveal the difference.
Give someone a prototype and observe how they interact with it. Avoid explaining every mechanic before the session unless the test specifically requires instruction.
Record what happens:
- Did players understand their objective?
- Where did they hesitate or become confused?
- Did they notice the mechanic or route the designer wanted them to notice?
- Were challenges too easy, too difficult, or unclear?
- Did unexpected behaviour reveal another possible solution?
These observations can inform revisions.
One playtest does not establish how all players will behave, and feedback should not automatically dictate a design change. The designer still needs to interpret what happened and decide what to test next.
Step 6: Show the changes that mattered
A case study becomes more informative when it connects feedback to design decisions.
Consider a level where playtesters repeatedly miss an important doorway.
A weak explanation would be:
The level was improved after testing.
A stronger explanation would document the observed problem, show the earlier layout, identify the proposed change, and present the revised version.
If players noticed the doorway more consistently in a subsequent test, describe that result accurately. If no follow-up test occurred, explain what was changed without claiming the problem was solved.
This distinction demonstrates judgment and avoids overstating results.
Step 7: Publish and test the portfolio
The portfolio itself should be easy to use.
Give each project a clear title, a short summary, and a visible demonstration. Include a description of the designer's role and links to supporting material.
Before sharing the portfolio, open it on another device or ask someone unfamiliar with the work to review it.
Check whether the person can identify the target role, understand the projects, access the demonstrations, and find contact details.
A portfolio is ready to share when its strongest evidence can be understood without requiring the designer to explain everything in person.
Digital Design students are able to pursue their passions at VFS via their student projects.Game Design Portfolio Examples by Specialization
Different design roles require different portfolio evidence.
| Specialization | Example portfolio project | What to explain |
|---|---|---|
| Gameplay Design | Character movement or combat mechanic | Input, feedback, timing, constraints, and revisions |
| Level Design | Playable mission or encounter | Routes, pacing, spatial decisions, player guidance, and testing |
| Systems Design | Resource economy or progression model | Rules, balancing assumptions, trade-offs, and outcomes |
| Narrative Design | Branching conversation or interactive story | Player agency, dialogue structure, consequences, and implementation |
| Technical Design | Scripted interaction or gameplay system | Implementation logic, dependencies, testing, and limitations |
| Game UX Design | Inventory or menu interaction | Player tasks, usability observations, interface revisions, and accessibility considerations |
Gameplay design portfolio example
A gameplay designer could create a short movement prototype featuring a dash mechanic.
The portfolio might show how the mechanic responds to input, what limits its use, and how it interacts with level obstacles. An annotated video could explain how the designer adjusted timing or cooldowns to achieve the intended challenge.
The important evidence is not simply that the dash works. It is how the designer evaluated and refined its behaviour.
Level design portfolio example
A level designer could create a short stealth encounter using two possible approaches.
The case study might include an overhead layout, initial blockout, enemy placement, gameplay walkthrough, and revised encounter.
The designer would explain how visibility, cover, and alternate routes affect player choices.
Visual polish can help communicate the final environment, but it should not replace the demonstration of spatial and gameplay design.
Systems design portfolio example
A systems designer might create a progression model for a small strategy game.
The portfolio could include resource rules, upgrade costs, expected player choices, and a spreadsheet used to test different configurations.
A useful case study would identify the original balancing problem and explain which assumptions changed.
Narrative design portfolio example
A narrative designer could build a short interactive conversation where player choices affect later dialogue or access to information.
The portfolio might include a branching diagram and a playable sequence.
This makes it possible to evaluate not only the writing but also how the narrative functions as part of an interactive system.
How to Build a Game Design Portfolio Without Experience
Professional credits are not a prerequisite for starting a portfolio.
Independent prototypes, school projects, game jams, collaborative games, and modifications of existing games can all provide evidence of relevant abilities.
The challenge is choosing a project small enough to complete while leaving enough room for meaningful design decisions.
Three beginner portfolio projects
1. Redesign an existing game level
Choose a game with accessible level-editing or modding tools. Study how one area guides player movement, introduces challenges, or uses cover.
Create an alternative layout with a stated design goal. Record the changes and explain why they were made.
Respect the game's modding policies, permissions, and any asset-use restrictions.
2. Build one mechanic and test it
Create a short prototype around a single interaction, such as a grappling hook, timed platform, or puzzle switch.
Focus on the behaviour of the mechanic rather than producing an entire game.
Document the initial version, feedback, and revisions.
3. Design a short branching narrative
Use an interactive storytelling tool such as Twine to create a scenario with meaningful choices.
Build a small, complete sequence where player decisions change dialogue, information, or outcomes.
Explain how the branching structure supports the intended experience.
Do game designers need to know how to code?
Game design and game programming are related but distinct disciplines.
Some designers implement mechanics directly through scripting and game engines. Others focus more heavily on systems, levels, narrative, or user experience while collaborating with programmers.
Technical requirements depend on the role and employer.
Designers who cannot yet program can still begin with paper prototypes, tabletop systems, narrative tools, visual scripting, or collaborative projects. However, understanding implementation constraints and learning to test interactive systems can expand the kinds of work they can demonstrate.
For beginners, the priority is to create evidence of design decisions rather than wait until every technical skill has been mastered.
How to Present a Game Design Project as a Case Study
A project case study explains the design challenge, the solution, and the evidence behind it.
It should be concise enough to scan, with additional material available for reviewers who want greater detail.
The following hypothetical example demonstrates the structure.
Example: Designing a Puzzle Level That Teaches a New Mechanic
Project: Short puzzle game prototype
Role: Gameplay and level designer
Goal: Introduce a switch-and-door mechanic without relying on lengthy text instructions
Tools: Game engine and basic level-editing tools
The design problem
Players need to understand that activating one switch changes the state of a nearby door.
The first puzzle should make this relationship clear. Later puzzles can introduce additional switches or timing constraints.
Initial design
The first version places a switch beside a door. The player activates it, sees the door open, and proceeds.
A second room adds another switch with a different relationship to the exit.
Testing
The designer observes a small group of players attempting the sequence.
Some players may fail to notice the first switch or may activate it without realizing what changed.
These are hypothetical observations for this example, not findings from an actual playtest.
Proposed revision
The designer might reposition the switch, adjust lighting, introduce a sound cue, or change the camera angle so that the door's movement is visible.
What the portfolio should show
Include a short clip of the initial design, a description of actual testing observations, the revised version, and results from follow-up testing if available.
The case study should explain why the chosen changes were made and acknowledge anything the tests did not establish.
How to Show Playtesting, Feedback, and Iteration
A list of improvements is less useful than evidence connecting a design decision to a specific problem.
Use this sequence:
Design intention → Player observation → Diagnosis → Revision → Follow-up result
For example, a designer may intend for players to notice a second route through an encounter. If testers consistently miss it, that observation suggests a possible visibility or navigation problem.
The designer might adjust lighting, landmarks, or the route's entrance.
The next step is to test whether players behave differently.
Not all changes improve a project, and not all feedback should be adopted. A thoughtful case study can explain why an idea was abandoned or why a trade-off remained unresolved.
Where Should You Publish a Game Design Portfolio?
The platform matters less than whether the portfolio makes relevant work easy to access.
| Platform | Useful for | Consideration |
|---|---|---|
| Personal portfolio website | Organizing projects and professional information | Requires setup and maintenance |
| itch.io | Sharing playable independent games and prototypes | Detailed design explanations may need separate pages |
| GitHub | Sharing source code, documentation, and technical projects | Code repositories alone may be difficult for nontechnical reviewers |
| ArtStation | Visual presentation, environment work, and supporting art | Should not replace gameplay evidence for design-focused roles |
| YouTube or another video platform | Demonstrating mechanics, levels, and walkthroughs | Video alone may not reveal the full design process |
A practical setup is a simple portfolio homepage containing links to dedicated project pages. Each page can include a short gameplay video, individual contribution statement, explanation of design choices, and a playable link where feasible.
Avoid making essential evidence difficult to access. If a downloadable build is unavailable, a clearly narrated video and supporting documentation can still explain the work.
Common Game Design Portfolio Mistakes
Showing projects without explaining individual contributions
A team project may involve programmers, artists, animators, designers, and producers.
Credit collaborators and specify which design decisions, systems, or features were your responsibility.
Using screenshots as the only evidence of game design
Screenshots can show visual quality, but they may not reveal how the game functions.
Include gameplay, layouts, systems, or design breakdowns where those are relevant to the target role.
Including too many unfinished projects
An ambitious unfinished game may contain useful work, but reviewers need enough completed material to evaluate the design.
Show a finished mechanic or level where possible, and describe remaining limitations accurately.
Writing documentation without demonstrating implementation
A game concept document explains intent. A prototype demonstrates how at least part of that intent works in practice.
When possible, connect written decisions to observable results.
Hiding important information
The reviewer should not need to search for project responsibilities, gameplay footage, or contact details.
Use descriptive project titles, readable headings, working links, and short introductions.
Claiming improvements without evidence
Avoid statements such as “playtesting proved the game was more engaging” unless the test and its limitations support that conclusion.
Describe what was observed, how many people participated when relevant, and what changed.
Game Design Portfolio Checklist
Before sharing a portfolio, review the following questions.
Portfolio direction
- Is the intended game design role or specialization clear?
- Does each selected project demonstrate a relevant skill?
- Is the strongest work easy to find?
Project evidence
- Can reviewers see gameplay or an interactive demonstration?
- Is the design challenge explained?
- Are important decisions documented?
- Is the individual's contribution identified?
- Does the case study show feedback or iteration where available?
Presentation
- Are project descriptions concise and readable?
- Do playable builds, videos, and supporting links work?
- Can reviewers access the content without unnecessary barriers?
- Are collaborators credited accurately?
- Is contact information easy to find?
If a project cannot yet answer the relevant questions, identify what evidence is missing before adding more content to the portfolio.
Often, the next useful improvement is a better explanation of an existing project rather than another new project.
Building Portfolio Projects Through Game Design Training
Game design education can provide structured opportunities to develop projects, collaborate with other disciplines, and receive feedback.
At Vancouver Film School, the 12-month Game Design diploma covers game mechanics, systems, level design, programming fundamentals, art, and team-based production.
Students work with tools including Unity and Unreal Engine and develop playable projects. The program's stated portfolio outcomes include multiple game projects and a team-developed final game.
The VFS Game Design program page also features student work, including Mach X and Unincrediball, offering examples of the kinds of projects developed during training.
A portfolio is ultimately judged by what it demonstrates. Whether someone is learning independently, collaborating on a game jam, or completing a formal program, the same central task remains: make the design work visible, explain the decisions, and provide enough evidence for another person to evaluate the result.
Explore the Game Design program at Vancouver Film School to review its curriculum, specializations, student projects, and portfolio outcomes.