The Game Design Process

By Game Design Ed [05.28.15]

[Game Design Ed is an online resource that collects game design hints, strategies, and solutions and distributes them to followers via Facebook, Twitter, and YouTube. Here, Ed outlines his personal game design process, to inspire anyone looking for advice in the field of game creation. Check out more of Ed's tips at Backyard Game Design.]

When you're designing a game, you are designing a complex system, so you'll want a series of steps called a process to help you build up and improve upon ideas as you create and improve that system.

What is your game design process?

When you're designing a game, you are designing a complex system, so you'll want a series of steps called a process to help you build up and improve upon ideas as you create and improve that system.

So I'll share my game design process.

My game design process includes 6 stages - capture, brainstorm, prototype, playtest, iterate, and implement.

These stages aren't necessary consecutive, different stages can occur simultaneously, and stages can be repeated.

The best example of this involves the prototype, playtest, and iterate stages, which generally form a cycle that is repeated multiple times as the game is iterated upon and improved.

Let's look at the 6 stages of my game design process in turn.  


My game design process begins with the on-going practice of capturing artifacts.

This is the stage of research. And you need to research a wide variety of fields: art, philosophy, rhetoric, marketing, mythology, literature, poetry, music, psychology, sociology, technology, economics, history... and anything else that can be combined to create a new and innovative experience.

You need to know a little about a lot of different subjects... the world is your classroom. So get out there and learn!

Sure, this includes playing games, but so much more:

Identifying the mechanics and how they balance with each other and connect to the theme and how it motivates the player, and incentivizes continued engagement...

It's not just playing games, it's studying them!

Seeing what's going on in games and knowing how other people have handled things in their games and being able to discern when you should use what others have done and not unnecessarily reinvent the wheel or when you could improve upon what they've done and knowing how to improve.

So this stage is a lot of research and study and inspiration. And you need a way to keep track of all this stuff.

If you have a great memory, great!

But if you're like me (and probably most other people), you don't. So you'll need to find a way to record all this knowledge for later use. I have notebooks full of my research, ideas, and inspiration.

How do you capture artifacts?


Brainstorming is the stage of the process where you take all of those artifacts you've captured and combine them in new ways to come up with innovative ideas.

Brainstorming starts with wild ideation. Combining artifacts and coming up with some crazy ideas.

However, it's not all out of the box thinking. As the brainstorming stage continues, you have to start introducing limits and constraints because games have limits - whether it's a limit of space or time or technology or money or culture or the norms of the game that supply reasons for not doing certain things you are physically capable of doing or whatever...  

Brainstorming isn't all just coming up with out of the box, crazy ideas without limits.

It isn't just letting your mind run free.

Sure, that's part of it, but it's only the beginning.

You need to subject your ideas to limits and constraints, make them sweat, see how they manage, and this is when you come up with the best ideas.


Once you have some good ideas coming out of your brainstorming, then you need to start prototyping.

Prototyping is the stage where you make a quick-and-dirty version of your game to see how and whether or not it actually works.

Don't get too invested in only one idea. Make various quick-and-dirty prototypes.

And don't worry about making the prototypes the best version of game possible. Make it quick!

My game design process subscribes to what is called rapid prototyping in which you get to a prototype of your game as quickly as you can to see how it works. Then you test it, find the problems, and make improvements through iteration.

And don't wait for a better way to build your prototype. Build it now!

If you're making a video game and you can't code, for example, that doesn't mean you can't make a prototype.

Make a paper prototype.

Use some dice or cards.

Whatever you have on hand is good enough to make a prototype.

This is an early stage of experimentation. And you need to make many rapid prototypes.


So you've made a prototype of your game, now you need to test that prototype. Play it yourself. Invite some friends and family to play your prototype.

This stage of the game design process is called playtesting. This is where you actually test your prototypes to see what works and what doesn't.

And be sure to always get feedback.

What did they like? What did they dislike?

But also watch them play.

Where did they get stuck? Where did they have fun?

Always playtest your prototypes. That's what they are for. To test and get feedback and then to improve through iteration.


You've received some feedback, data, and analytics from playtesting your prototypes.

Now you need to integrate some of this feedback and update your prototypes.

This is the iteration stage of the design process.

What can be changed? What should be changed? What sort of changes will you make and test?

This brings us back to the prototype stage where you build another prototype that improves upon your previous prototypes based on the feedback you've received in playtesting.

And then you playtest your new prototype.

And then iterate again.

And then back to the prototype stage where you'll be cutting different prototypes that don't work out. And cutting features that don't work. And adding new features to test. And cutting features that used to work, but now don't.

And eventually you'll begin to focus on one prototype.

And you'll keep iterating on it.

And eventually make a wireframe.

And a first playable demo.

And an alpha build.

And a beta build.

And then eventually after enough cycles through the prototype, playtest, and iteration stages you'll eventually get to the stage of implementation.

Iteration is something we do in all areas of life, not just in game design. We try something and then change it based on the feedback we get.


So after going through the iterative cycle enough times, hopefully you come out the other side with a good game.

You have reached the implementation stage where you finally take your game and release it to a wider audience to experience.

But don't be misled. Implementation doesn't mean that your game is done. Because you'll still be finding out things that could make your game better.

For example, the game of basketball was invented in 1891 by Dr. James Naismith as an activity for his students to stay active on a rainy day. Naismith used elements of games, such as Duck on a Rock, that he had"captured" in the research stage of the design process. At its inception, the game didn't have a backboard, which was added the following year after the game was playtested and Naismith found out that spectators on the balcony that the peach baskets were nailed to would interfere with the gameplay. Also, it was originally played with a soccer ball - the orange basketball we know today wasn't invented until the 1950s. Dribbling was added with the new ball - previously the ball was moved by passing. Originally, the court was half the size it is today and the game was played with 9 players on each team. The three point line was first tested in 1945 and is still being iterated and tested - the NBA last changed the distance of the three point line in 1998 and the WNBA last moved it in 2013 and they both use slightly different distances! So the game of basketball has gone through a lot of prototyping, playtesting, and iterating. And I'm fairly certain that it will continue to do so. And this is long after basketball's implementation.

Like basketball, your game can be changed after implementation as well.

Maybe it's changing a sound or effect.

Or adding or taking away a feature.

Or adding more content.

Or changing how many cards you deal.

Or whatever.

So the game isn't done. Totally complete and 100% Perfect. But if it's good enough, put it out there.

If you're waiting for it to be perfect, you'll never put it out there because it will never be perfect. Just put it out there. You can keep working on it, but put it out there.

The ABC's of Sales is "always be closing."

In games, it's "always be shipping."

Wait... that ABS. Nevertheless, always be shipping!

Sometimes being good enough is good enough and this is one of those times.

Implement your game.

Put it out there.


So that's my game design process - capture, brainstorm, prototype, playtest, iterate, and implement.

As I said at the beginning, these stages aren't necessary consecutive, different stages can occur simultaneously, and stages can be repeated.

Or put differently, game design is never as simple as this.

It can be a lot messier.

And each game you design will have new circumstances and obstacles.

So don't be misled: this process isn't meant to make you think that game design is simple and easy.

This process is only meant to add some structure and normalcy to something that, in practice, is new, messy, and exciting.

What's your game design process? 

Return to the web version of this article
Copyright © UBM TechWeb