Sefism Game Development Roadmap

What this roadmap is

The Game development roadmap is Sefism's step-by-step path from "I want to make games" to a set of small, finished, released games and a clear view of the industry. It is built around one idea that runs through every stage: finish small games. You start by cloning a classic, learn your engine through one growing project rather than ten throwaway tutorials, and release on itch.io before you ever think about Steam.

When you set it up, you choose your engine: Unity (C#, the most tutorials, strong for mobile and indie), Godot (free and open source, GDScript) or Unreal Engine (Blueprints and C++, high-end 3D). The stage list is the same for all three. The programming stage changes completely with the engine, and the later stages name each engine's version of a system and point to that engine's own docs and courses.

What you can do at the end

The roadmap sets six outcomes. By the end you should be able to:

• Scope, build and finish a small game around one core mechanic, then release it on itch.io as a browser or desktop build.
• Write clean gameplay code using your engine's lifecycle, components, events, input, physics, UI and audio systems.
• Use vectors, delta time, interpolation and camera tricks so movement is smooth and actions feel responsive.
• Run playtests with real players, find the problems in what they do, and change the design based on evidence.
• Profile and build for PC, web or mobile, and know the steps, fees and rules for Steam, Google Play and the App Store.
• Put together a portfolio of small finished games aimed at a studio role, with a realistic view of indie income.

Who it suits, and who should start elsewhere

It suits students and developers who want to make and ship their own games, whether as a hobby that turns into a portfolio, a route into a studio programming role, or a first step towards selling a game.

It assumes you are willing to write code. If you have never programmed at all, do the first stages of the Programming foundations roadmap first; the engine courses go much faster once variables, functions and loops are familiar. If your real goal is selling a product of any kind rather than games specifically, the Build and sell your own product roadmap covers pricing and marketing in more depth. If you mainly want to design how games look and feel rather than program them, look at UI/UX design alongside this one.

Time and pace

The eight stages add up to about 214 hours of focused work. The first stage is marked as a foundation, so if you already use an engine comfortably you can skim it or skip it, and your plan adjusts.

On Sefism you pick how many hours a week you have, and the roadmap turns stage hours into weeks:

A student's week (10 to 12 hours): two weekday evenings on the stage's course or docs, one evening changing your project without instructions, and a longer weekend session building and committing. Enter a game jam when one lines up with the end of a stage.

Someone working full time (about 5 hours): one weeknight on learning, one short session to commit a small change, and two or three hours at the weekend building. Keep the scope even smaller than feels necessary; a finished two-week game beats a half-built one.

Stage by stage

1. How games are made (about 12 hours, foundation)

What a game is under the hood and how to pick a first project you can finish. Topics: the game loop, what an engine gives you and what it costs (including licence terms for a commercial release, which you check on the official pages), scope control and prototypes, cloning a classic to learn the engine, 2D or 3D for your first games, game jams, and version control for game projects.

Milestone: your engine installed, one classic game cloned and pushed to Git with the right .gitignore, and a one-page plan for your first original game with a written out-of-scope list.

2. Programming for games (about 40 hours)

Writing gameplay code in your engine's language. In Unity that means C# for Unity, the MonoBehaviour lifecycle, and components talking through references and C# events. In Godot it means GDScript with static types, nodes, scenes and the scene tree, and signals. In Unreal it starts with Blueprints, then actors, components and the gameplay framework, Blueprint communication and event dispatchers, and C++ with UCLASS, UPROPERTY and UFUNCTION. Every engine then covers small scripts and composition, exposed variables and tuning, state machines, and debugging games.

Milestone: a small game in your own code with a player state machine, an enemy, a health component that raises an event, and a UI that listens to it, with tuning values exposed in the editor.

3. The engine in depth (about 50 hours)

The systems nearly every game uses, built into one growing project: scenes and levels and moving between them, prefabs, packed scenes and Blueprint classes, input actions for keyboard and gamepad, physics bodies, collisions, triggers and layers, animation and animation state machines, game UI (HUD and menus), audio, and saving settings and progress.

Milestone: one small complete game with a menu, two levels with data carried between them, enemies spawned from templates, input that works on keyboard and gamepad, animated characters, a HUD, separate music and effects volume sliders, and saved settings. The stage's checklist also asks you to enter a game jam with what you have learned.

4. Game maths and feel (about 25 hours)

The maths that turns input into smooth motion and the feedback that makes a game feel responsive: vectors, transforms in local and world space, delta time and the fixed timestep, interpolation, easing and tweens, rotations and quaternions, cameras that help the player, juice and feedback, and randomness with control.

Milestone: a movement playground with frame-rate independent movement, eased acceleration, a smoothed camera with a dead zone, coyote time and jump buffering, and at least five kinds of juice, each with a toggle so you can show before and after.

5. Game design basics (about 20 hours)

What makes a game worth playing: the core loop, mechanics and the behaviour they create, level design that teaches, difficulty curves and balance, onboarding without walls of text, playtesting with real players, and turning feedback into changes.

Milestone: a one-page design document and a playtest log from at least two rounds with five new players each, showing observations, the problems you grouped them into and the changes you made.

6. Art and audio for programmers (about 20 hours)

How to ship a good-looking game without being an artist: greyboxing and visual readability, asset licences, free asset sources, simple styles you can make yourself (pixel art and low-poly), sprite sheets, tilesets and atlases, sound effects, and music with a basic mix.

Milestone: your game with one consistent art style, sound on every player action, looping music on its own volume slider, and a credits file listing every asset with its source and licence.

7. Performance, builds and shipping (about 35 hours)

Making the game run well on real hardware and releasing it. Topics: frame budget and profiling, draw calls and batching at intuition level, object pooling and garbage, building for PC, web and mobile, testing real builds on real hardware, releasing on itch.io, Steam Direct and the release process, mobile stores and platform requirements, and the store page, trailer and wishlists.

Milestone: a released game on itch.io, profiled on your slowest target device and smoke tested on at least two other machines, plus a written release plan for Steam or a mobile store listing each step, fee and review with its timing.

8. Money and careers (about 12 hours)

An honest view of the business side: indie income, payouts and tax forms, studio roles for programmers, a portfolio of small finished games, how studios hire programmers, publishers and deals, scams aimed at game developers, and patches and post-mortems after launch.

Milestone: a portfolio page with three small finished games aimed at one studio role, each playable or shown in a short video, plus a written post-mortem of your latest release.

Projects to build alongside

The roadmap suggests four final year or portfolio projects from the Sefism library, in order of ambition:

• Finished small 2D game with a playtest log, the first one to do: one mechanic, finished, playtested and released.
• Local multiplayer party game with controller support, which stretches input, game state, UI and group playtesting.
• Data-driven tower defence with balancing tools, a strong piece for gameplay or tools roles.
• Procedural level generation with guaranteed solvability, an advanced challenge that works in any engine.

How it works on Sefism

The public page at /roadmaps/game-dev/ shows the full stage list, with the first two stages open to read. Everything on Sefism is free to learn from. Some actions use credits: adding a roadmap to your dashboard is one of them, and your first roadmap is free. New members get starting credits when they join, and if you are learning seriously and run out, you can ask for more.

Adding the roadmap to your dashboard opens every stage in the member area. There you choose your engine, set your weekly hours and how familiar you already are, tick off topics and stages as you go, and each topic comes with a short explanation, a check question to answer without notes, and a prompt you can paste into an AI assistant so it quizzes you rather than doing the work. Following the roadmap also unlocks its companion cheat sheet. If you get stuck on any stage, you can send Tauseef a question or book a 1:1 session.

The companion cheat sheet

The Game development cheat sheet follows the same order in nine chapters, with Unity, Godot and Unreal editions. Use it to revise a stage after you finish it, or skim a chapter before a jam or a new feature.

Related on Sefism

• Game Programming Patterns and Game Maker's Toolkit, both used in several stages.
• itch.io for your releases and GMTK Game Jam for your first jam.
• I understand tutorials but cannot build anything myself, the exact problem stage 2 is designed to fix.
• How do I build a developer portfolio as a beginner?
• Which final year project will actually help me get a job?

What you can do afterwards

You will have several small finished games, at least one released on itch.io, a playtest log that shows how you make design decisions, and a portfolio aimed at one studio role. From there you can apply for gameplay or tools programming roles, keep releasing and grow towards a Steam launch, or carry your engine skills into adjacent work such as interactive training or AR.

Frequently asked questions

How long does it take to learn game development? This roadmap is about 214 hours of focused work. At 12 hours a week that is roughly 18 weeks; at 5 hours a week, closer to 43. Learning never really stops, but by the end you will have shipped real games.

Should I learn Unity, Godot or Unreal Engine? Pick the one that matches the games you want to make and stay with it for at least three months. Unity suits mobile and indie games in C#, Godot is free and open source with GDScript and suits 2D and small 3D, and Unreal leads in high-end 3D with Blueprints and C++. The first stage asks you to read your engine's licence page and write down what a commercial release would cost.

Do I need to be good at art to make games? No. Stage 6 is written for programmers: greybox first, use one consistent family of free assets with the right licence, or pick a simple style such as pixel art or low-poly that you can produce yourself.

Can I make a living from indie games? The roadmap is honest about this: most games earn little, and that is fine while you are learning and building a portfolio. Stage 8 advises keeping a stable income while you grow and never paying anyone who promises to publish, market or hire you.