Game Developer Roadmap: From Zero to a Shipped Game

Game Developer Roadmap: From Zero to a Shipped Game

A game developer spends most of the week reading someone else's code, fighting frame budgets, and implementing the unglamorous eighty percent — menus, save files, input remapping, and the bug where the character falls through the floor. Expect twelve to twenty-four months to a first paid role, longer than most software paths, and understand up front that the pay is lower and the hours are worse than general software engineering for the same skill.

Updated for 2026. Salary figures are indicative and move quarterly.

What This Role Actually Does

The fantasy is designing worlds. The reality is a bug ticket that says "player can clip through the elevator if they jump while the door animation is on frame 14."

Gameplay programmers spend their days translating a designer's intent into systems that behave consistently under inputs nobody anticipated. Most of that is state machines, collision handling, animation blending, and tuning numbers until something feels right — and "feels right" is not a specification you can unit test.

The second big chunk is performance. Games have a hard frame budget: at sixty frames per second you have roughly sixteen milliseconds to do everything. Every feature competes for that budget, and profiling is a weekly activity rather than an occasional one.

Then there is production reality: version control conflicts on binary assets, builds that break on one console and not another, certification requirements for platform holders, and long stretches of the schedule where you are polishing rather than creating.

What people wrongly imagine it is: that you get paid to have ideas. Ideas are the cheapest thing in the industry. Studios are full of people with better ideas than they have time to build, and nobody is hired for their concept document.

The other misconception is that playing a lot of games prepares you for making them. It gives you taste, which is genuinely useful, but taste without execution is the most common profile in the rejection pile.

The Honest Part: Pay and Hours

Say this out loud before you commit years to it.

Game development pays less than general software development for equivalent skill. A gameplay programmer with five years of experience typically earns well below what a backend engineer with five years earns, and the gap widens at senior levels because studios rarely match the equity packages that large technology companies use.

The reason is not that the work is easier. It is that far more people want to make games than there are seats, and studios can hire excellent engineers at rates a fintech company could never get away with.

The hours are also worse. Crunch — extended mandatory overtime near a milestone or ship date — remains common enough across the industry that you should assume you will encounter it, even though many studios have publicly worked to reduce it. Ask about it directly in interviews and treat vague answers as answers.

Layoffs are cyclical and severe. The industry contracts hard after over-hiring periods, and entire studios close after a single underperforming title. Budget your career for volatility.

None of this means do not do it. It means do it with your eyes open, and consider keeping a general software skill set as a fallback.

Unity vs Unreal vs Godot

The recommendation: learn Godot if you want to finish your first game fastest, Unity if you want to be employable, Unreal if you specifically want AAA three-dimensional work. Do not learn all three. Engine-switching is a procrastination behaviour disguised as research.

The Roadmap

Stage 1 — Programming fundamentals

What to learn: C# if you chose Unity, GDScript if Godot, C++ if Unreal. Variables, control flow, functions, classes, collections, and — importantly — reading a stack trace. Add Git and Git LFS, because game repositories are full of large binary files.

Realistic time: 6–10 weeks at 10–15 hours per week.

Free resources by name: freeCodeCamp for general programming; Microsoft Learn's free C# path; the official Godot documentation, which includes a genuinely good scripting introduction; learncpp.com for C++; The Odin Project if you want disciplined structure and are willing to accept its web focus for the fundamentals.

Portfolio project: a text-based game — a number guesser, then a small text adventure with an inventory. No engine. This isolates programming from engine confusion.

You are done when: you can write a program with three interacting classes without copying structure from a tutorial, and you can debug a crash by reading the error rather than searching it.

Stage 2 — Your first finished game, deliberately tiny

What to learn: The engine editor, the scene and node or GameObject model, the update loop, input handling, collision, and — most importantly — shipping. Build an executable. Put it on itch.io. Let a stranger play it.

Realistic time: 4–6 weeks.

Free resources by name: Unity Learn's free pathways, including Junior Programmer; GDQuest's free Godot tutorials and the official Godot step-by-step guides; the Brackeys YouTube archive, still one of the best free Unity foundations even though the original series ended; Unreal Online Learning courses from Epic.

Portfolio project: a complete arcade game — Pong, Breakout, or a single-screen platformer — with a title screen, a game over screen, sound, and a public build. Two hundred lines is fine. Finished is the requirement.

You are done when: a person you have never met has played your game start to finish from a downloaded or browser build, without you sitting next to them explaining it.

Stage 3 — Game maths, physics, and feel

What to learn: Vectors, dot and cross products, interpolation and easing, transforms and parent-child hierarchies, delta time, fixed timestep versus frame-dependent updates, raycasting, and collision layers.

Then game feel: coyote time, input buffering, screen shake, animation curves, hit pause. These are what separate a game that technically works from one that feels good.

Realistic time: 6–8 weeks.

Free resources by name: Freya Holmér's free maths-for-game-developers videos; Red Blob Games for interactive explanations of pathfinding and grid maths; Game Programming Patterns by Robert Nystrom, free in full online; Catlike Coding's free Unity tutorials.

Portfolio project: a platformer with genuinely good movement. Just movement. Tune jump arc, acceleration, coyote time, and input buffering until it feels better than the first thing you built.

You are done when: you can explain why your jump feels good using specific parameters, not vibes.

Stage 4 — Systems, architecture, and content

What to learn: Scene management, save and load, data-driven design (scriptable objects, resources, configuration files), event systems, object pooling, state machines, basic AI with behaviour trees or finite state machines, UI, audio mixing, and localisation basics.

This is where you learn to structure a project that survives past week three.

Realistic time: 8–12 weeks.

Free resources by name: Game Programming Patterns again, seriously; Unity's free Open Projects repositories on GitHub; the Godot demo projects repository; Kenney's free public-domain art packs so art never blocks you.

Portfolio project: a small game with real content — perhaps twenty minutes of play — with a working save system, a settings menu, and at least three enemy types driven by data rather than hardcoded.

You are done when: you can add a new enemy or level to your game without editing five unrelated files.

Stage 5 — Ship two more small games and enter a jam

What to learn: Scope control as a practised skill. Enter a game jam — Ludum Dare, GMTK Game Jam, or one of the many jams hosted on itch.io — and finish inside the deadline.

Jams do in a weekend what solo projects fail to teach in a year: they force you to cut.

Realistic time: 8–12 weeks for two to three jam or micro projects.

Free resources by name: itch.io jam listings; the Ludum Dare site; OpenGameArt and freesound.org for assets; Aseprite's source is free to compile if you want pixel art without buying anything.

Portfolio project: three finished small games, publicly playable, each with a short devlog explaining one technical problem and how you solved it.

You are done when: you have finished three games and you can state, honestly, what you cut from each and why.

Stage 6 — Specialise and go deep

What to learn: Pick a lane, because studios hire specialists.

Realistic time: 10–16 weeks to a credible depth.

Free resources by name: The Book of Shaders for graphics; Gaffer On Games articles for networking, still the reference; GDC talks free on YouTube via the GDC channel; Scratchapixel for rendering theory.

Portfolio project: a deep, narrow artefact — a custom shader collection with explanations, a working rollback netcode demo, or a level editor tool for your own game.

You are done when: you can hold a technical conversation in your specialism with someone who does it professionally and not run out of depth in ten minutes.

Stage 7 — Job readiness

What to learn: Portfolio presentation, a reel or short gameplay videos, a public code sample studios can read, plus interview preparation: data structures and algorithms, C++ specifics if targeting AAA, and performance reasoning.

Realistic time: 6–10 weeks alongside applications.

Free resources by name: NeetCode free lists; GDC vault's free talks on hiring and portfolios; Grackle HQ and studio career pages for the real requirement language; Work With Indies and Hitmarker job boards.

Portfolio project: a portfolio site — not a PDF — with three playable builds, thirty-second clips, and one written technical breakdown per project.

You are done when: a stranger can understand what you built and what you personally did within sixty seconds of landing on your page.

Salary and Job Titles

Figures are indicative ranges drawn across the source types people actually use: Levels.fyi for larger studios and publishers, US Bureau of Labor Statistics software developer data as a floor reference, the Stack Overflow Developer Survey for self-reported spread, and Glassdoor aggregates for mid-sized studios. Game-specific compensation is less well documented than general software, so treat these as rough. They move quarterly and the industry's hiring cycle is unusually volatile.

Compare that to the mobile, backend, or cloud roadmaps on this site and the discount is visible at every level. Graphics, engine, and network specialists sit at the top of these bands and are the main exception.

Canada has real concentration in Montreal, Vancouver, and Toronto with strong studio presence, and CAD figures are structurally lower than US numbers even before exchange rates. Indie income is not on this table because for most independent developers it is not a salary, it is a lottery ticket with a long tail.

Who Should Not Take This Path

If you need financial security in the next five years. Between the lower pay, the cyclical layoffs, and the studio closures, games is a poor choice for someone supporting dependents on a single income with no buffer.

If you resent doing the unglamorous eighty percent. Menus, save systems, controller remapping, localisation, platform certification. If only the creative fifth interests you, the other four-fifths will grind you down.

If you cannot cut your own ideas. Scope control is the core professional skill. Someone who cannot delete a feature they love will never finish a game, and finishing is the entire signal.

If you want to work on your own vision from day one. Studio work is executing someone else's game. If that sounds intolerable, you want indie, and you should read the financial paragraph again.

If playing games is your main source of rest. Many people find that making games permanently changes how they play them, and lose the hobby that made them want the career.

The Five Mistakes

1. Choosing a project ten times too big. The open-world RPG as a first solo project is the single most reliable predictor of never finishing anything. Build something embarrassingly small and finish it.

2. Engine hopping. Trying Unity, then Godot, then Unreal, then back, is procrastination wearing a research costume. Pick one, ship three games, then reconsider.

3. Building an engine instead of a game. Writing your own renderer teaches a lot and produces no portfolio. Do it after you have shipped games, not instead.

4. Treating art as a blocker. Use Kenney packs, primitive shapes, or programmer art. A finished game with cubes beats an unfinished game with beautiful sprites, every time.

5. Never letting anyone else play it. Your game is obvious to you because you built it. Ten minutes of watching a stranger play, silently, will teach you more than a month of solo iteration.

Print This Section

GAME DEVELOPER ROADMAP — STAGE SUMMARY

0. READ FIRST: games pay LESS than general software for the same skill,
   hours are worse, layoffs are cyclical. Proceed knowingly.

ENGINE PICK: Godot = finish fastest | Unity = most jobs | Unreal = AAA 3D

1. PROGRAMMING           6-10 weeks  C#/GDScript/C++ + Git LFS, no engine
   Done when: you debug from the error, not the search bar

2. FIRST TINY GAME        4-6 weeks  Engine basics, BUILD IT, publish to itch.io
   Done when: a stranger finished it without your help

3. MATHS + GAME FEEL      6-8 weeks  Vectors, lerp, delta time, coyote time
   Done when: you explain good jump feel with parameters

4. SYSTEMS + CONTENT     8-12 weeks  Save/load, data-driven design, FSM, UI
   Done when: adding an enemy touches one file, not five

5. THREE SMALL GAMES     8-12 weeks  Game jams. Scope control as a practice
   Done when: you can say what you cut and why

6. SPECIALISE           10-16 weeks  Gameplay | Graphics | Engine | Network | QA
   Done when: you hold depth with a professional for 10+ minutes

7. JOB READY             6-10 weeks  Playable portfolio + clips + breakdowns
   Done when: a stranger gets it in 60 seconds

TOTAL: roughly 12-24 months. Longer than most software paths.
SCOPE CONTROL IS THE JOB. Finish small things repeatedly.

🔗 Read next: Frontend Developer Roadmap if the pay gap concerns you and you want a nearby path with better economics, and the pillar guide Tech Career Roadmaps Compared for a side-by-side of every route on salary, time to hire, and job security.