How Do Solo Game Developers Make Video Games?

How do solo game developers make video games? Game development is a large topic to cover with many nuances. Today, we’ll walk through the process that solo game developers go through to develop the game itself.

Why is this important for solo game developers to understand this process? 

Like the gaming industry, you have limited resources. Your time. Your money. Your effort. Your skills. Unlike the industry though, you are the driving force behind your game. You are responsible for everything. Marketing. Business. Art. Engineering. Building the game itself is a tiny part of the process. But, it is the core of the entire process.

How does the gaming industry build games? It breaks down into 6 phases:

1. Idea
2. Pre-Production
3. Production
4. Post-Production
5. Release
6. Post-Release

Where does the game fit into each of these phases? Which ones are specific to the game themselves? These are vague and we can do better. Let’s break it down further.

Here’s how each of the 6 game industry phases relate to the game itself:

1. Idea -> Idea
2. Pre-Production -> Prototype
3. Production -> Iteration
4. Post-Production -> Polish
5. Release -> Release
6. Post-Release -> Post-Release

Let’s walk through each one of these game phases.

Idea 

The idea is the thought or scenario for a game. This is the backbone and vision for the game. The more catchy, fun, and original it is, the better. The goal of this phase is to have an idea that you build a game off of.

It can come from anywhere: video game, board game, personal background, an experience, your brain, random idea generator, AI, players, friends, a team, group of people, family, etc.

The game idea we are going to use throughout this blog is for a survival crafting game.

Prototype

A prototype is the smallest, quickest, playable version of the game that reflects the game’s core idea. The goal of this phase is two fold: Build the prototype and decide whether this prototype is worth growing into a full game.

Let’s elaborate on the definition of what makes up the prototype.

Smallest

Smallest meaning you only want the core game elements present in the prototype.

How do you do this?

Start by disassembling the game idea into its core gameplay loop. A gameplay loop contains the main tasks that the player will be doing throughout the game. 

In a survival crafting game, the core gameplay loop would look like this: gather resources, craft items and weapons, defeating enemies, and repeat. 

The next step is to break down each task into systems that make the task possible. Then, you build those systems.

For example, to gather a wood resource, what systems do you need to get wood? Here’s a few you would need:

1. To get wood from a tree, you need a tree to exist. Build a tree.
2. How do you interact with the tree? You need to hit it. Need a system to contain a way to trigger actions with the keyboard and mouse. Then, you need to use that system to trigger actions like hit. You need a system on a tree to recognize the hits from you.
3. How does the tree know when to turn into wood? When it’s destroyed, after 3 hits. Then, you’ll need the tree to have a health system.
4. How do you get to the tree? You need to move to it. Need a player controller for the player to move around.
5. Once you get the wood, how do you pick it up? Need a pick up system to pick up nearby resources.
6. Once you pick up the wood, where is it stored? Need an inventory system to track the wood you’ve picked up.

You continue this process with each task until you have gone through each one.

Quick & Playable

We want a fast way to play and test out these tasks and the game itself. The two ways to do this are with a physical prototype or with a digital prototype.

The physical prototype is building the pieces and components that make up the game. Then, using them to interact with rules (which are in your head) and the environment. This method is quick and tangible. Unfortunately, it doesn’t scale well. It doesn’t work for all games (like our survival crafting game). You’ll need to convert it into a digital format anyway for the rules, systems, etc.. It’s hard to share and get feedback. For these reasons, solo developers favor the digital prototype.

The quickest way to create a playable digital prototype is with a game engine.

What is a game engine?

It’s a software tool embedded with many features and functionality that you build your game on top of. A good way to think about it is with an analogy: a game engine to a game is what a foundation is to a house. They are convenient, powerful, and ready to use (little to no setup required). 

If you are new to game development, use a game engine. Picking one is a whole topic in itself. Depends on:

1. What matters to you (e.g. support, tutorials, asset store, open source)
2. What kind of game you’re building (e.g. 2D vs. 3D, pixel art vs realistic)
3. Your skills and experience you have (e.g. programming). 

Do your research and pick one. Don’t think about it too long.

Reflects the game’s core idea

Are you building systems related to the game idea and the game you want to make? If so, keep it. Else, drop it.

Using our survival crafting game example, a system to transition from day to night and back is nice. But, the game doesn’t depend on it. 

This also includes the art. Use simple images for 2D and basic shapes, like spheres, capsules and cubes, for 3D. Remember we want small, quick and playable. This also avoids scope creep, a process of adding features until the game it’s too big and too complex to finish.

When you finish the prototype, it’s going to feel underwhelming to play. 

Why is that? We have expectations. 

First, we have expectations of ourselves. We know we can do better. 

Second, we have expectations based on the games we’ve played. We’ve had great experiences and memories playing these amazing feeling and looking games. This prototype is not that.

This is 100% normal.

Remember the end goal of the prototype phase: decide whether to transform this prototype into a full game. 

Deciding this is up to you and your goals. Is it fun? Does it offer a different and unique experience? Play around with it. Explore the space of the game idea. Don’t be afraid to experiment. This is when you should share it with people and get their thoughts with a playtest. As this blog relates to development of the game itself, we are going to skip it right now and move on to the iteration phase.

Iteration

This is when you start to build up the game. You will spend a majority of your time here assembling and expanding the core gameplay loop. You’ll work on elements of the game that not only add breath but also depth. 

For our survival crafting game example, during this phase you might do the following:

1. Make more enemies (Zombies, Raiders, Mercenaries)
2. Add more resources to gather (rock, metal)
3. Make more weapons (swords, throwing knives, guns)
4. Create more items (first aid kits, pickaxe, torch)
5. Expand crafting to make interesting weapons and items (bottle + gas + cloth = molotov cocktail)
6. Create puzzles to complete (Need key to unlock safe, solve riddle to find rare resources)
7. Start a progression system or skill tree (Learn to craft more items, enhance melee abilities)
8. Make more levels (dense green forest, snowy mountain, dry arid desert)
9. Incorporate art assets (rocks, trees, buildings, first aid kits, swords, guns, zombies, birds, bears, etc.)
10. Create a menu with settings (audio, video, gameplay)
11. In-Game UI
12. Day and Night Cycle
13. Hunger, Stamina & Hydration system
14. Interesting enemy AI (enemies maneuver in groups, find cover, attack with different weapons, reposition themselves)
15. Narrative (why are you trying to survive?)
16. Vehicles (Cars, motorcycles)

A key part of this phase (as the title suggests) is to iterate. Build. Test. Analyze. Repeat.

Build a system or improve an aspect of the game. Test to make sure it works. Analyze if it improves the game and aligns with the game’s idea. If it does, great! Move to the next thing. If not, why not? Was it not fun? Hard to use? Decide whether to improve it, shelve it or drop it.

With your time, effort and dedicated focus, the game will grow. It will morph into the game you are expecting. The game may scratch the itch but is not satisfying. It’s missing that extra umph that makes it special and impactful. This is where polish comes in.

Polish

Polish is the process of making the game look pretty, feel good to play, and elevate it to the next level. An important step before beginning the polish phase is that the game should be close to finished. Adding more content, systems and assets into the game puts you back into the iteration phase. Polish can be a distraction if done too early.

What do you do during this phase then? Integrate those extra details that make the game pop.

Using our survival crafting game example, this could include but is not limited to:

1. Ambient sounds (water flowing, birds chirping) 
2. Music (tense music when an animal chases you, cheerful music when walking through a meadow, creepy music when walking around in the dark)
3. Sound effects (firing a gun, chopping a tree, walking on rocky terrain, “oof” and “uggs” when taking damage)
4. Particles (gun’s muzzle flash, wood chunks fly off of trees when hit, smoke rising from a fire)
5. Post-processing (red bloody outline on screen when getting hit, chromatic aberration when feeling woozy)
6. Screen shake (gentle sway when running, violent shake when taking damage)
7. Visual effects (grenade explosions, x-ray vision)
8. Animations (squash & stretch, player running, UI Transitions)

At this point, the game should look, feel and play like the game idea you had to begin with. If it doesn’t, that’s ok. Go back to the iteration phase to add content or keep adding polish. It’s rare to get it right the first time. Take a few passes through the iteration and polish phase to get it where you want it and are happy with it. Don’t be afraid to get feedback from others too.

Once you feel it’s ready, the next step is to put it into the player’s hands. Releasing it.

Release

Congrats, you’ve made it to the end! 🥳 Time to let the game shine and let your players play it. Releasing your game means to share it online for players to access it by put it on a marketplace. 

For PC, a few locations are Steam, itch.io and Epic Games. For Mobile, there is the iOS App Store and Google Play Store. For consoles, there is Sony’s Playstation Store, Microsoft’s Xbox Store and Nintendo’s Store & eShop.

Post-Release

You finished the game. Where do you go from here? There are three options: Expand it, Maintain it, or Leave it as-is. 

You can expand the game using updates or Downloadable Content (or DLC). This could be adding more to the game that you couldn’t fit or didn’t have time to put in before release. 

Examples for our survival crafting game could be:

1. Additional guns
2. Cosmetic upgrades
3. More game modes (like playing as an animal and hunting the player)
4. A level editor
5. Mod support
6. New levels (like an abandoned metropolitan area)

You can maintain the game through bug fixes to improve the current player’s experience.

Examples could be:

1. Prevent visual glitches
2. Stopping enemies running through walls
3. Fix the save system
4. Prevent item duplication
5. Fix the inventory

You could leave it as-is. The game is what it is. You get what you get and that’s it. No planned updates, fixes or DLC.

It depends on you, your goals and your time. It’s up to you on what to do next.

Summary

The process solo developers go through to build a game breaks down into 6 phases: Idea, Prototype, Iteration, Polish, Release, and Post-Release. Each phase impacts the game in a specific way. 

1. Idea: Have an idea for a game to create.
2. Prototype: Build a small, quick, playable version of the game that reflects the game’s core idea.
3. Iteration: Assemble and expand on the game’s core gameplay loop.
4. Polish: Integrate extra details that make the game pop and stand out.
5. Release: Share the game for others to play.
6. Post-Release: Expand, Maintain, or leave the game as is.

I hope this provided a sneak peek behind the curtain of game development.