
describe the phases of game development from concept to post-launch, explain why the process loops back on itself, and draw it as a flowchart.
Instruction
Games are not written from start to finish like an essay. They are grown, tested and cut back, again and again. Studios name the phases differently, but most follow the same shape.
1. Concept. A small group answers three questions: what does the player do (the core verb), who is it for (the audience), and why would they care (the hook)? The output is a pitch: a paragraph, a few sketches, sometimes a tiny prototype. Many concepts die here, cheaply, which is the point.
2. Pre-production. The team proves the idea can work. They build prototypes, rough versions that test one question each (“is grappling fun?”), and write a design document that records decisions. They plan the schedule, the budget and the tools. At the end, a studio or publisher often decides whether to fund full production. The most valuable pre-production output is a vertical slice: a short section of the game built close to final quality, which proves the team can make the rest.
3. Production. The longest phase. Artists, designers, programmers and audio staff build content: levels, characters, systems and sound. Producers track tasks and cut features that will not fit. Milestones mark progress; two common ones are alpha (every feature is in, even if rough) and beta (all content is in and the team is mainly fixing bugs).
4. Testing and polish. QA testers hunt bugs, playtesters report confusion and boredom, and the team adjusts difficulty, feedback and performance. Polish is the difference between “it works” and “it feels good”: a screen shake on impact, a sound when a coin is collected, a menu that remembers your settings.
5. Launch and live operations. The game is released. Many games keep changing afterward through patches, updates and new content based on player data and feedback.
Why it loops. Drawn as a straight line, the pipeline is misleading. At every phase, testing sends the team back: a prototype shows the grapple is dull, so the concept changes; a beta test shows level 3 is too hard, so production reopens it. This is iterative design: design, build, test, learn, repeat. The loop is cheapest early. Changing a rule on paper costs minutes; changing it after artists have built forty levels around it costs months. That is why designers test ideas as early and as roughly as possible.
Keeping a team on track. Teams break work into tasks small enough to finish in a day or two, and track them on a board with columns such as To do, Doing and Done. They meet briefly and often to surface problems early. Flexibility matters as much as planning: a plan that cannot change when a test fails is not a plan but a wish. A useful habit is the question “what is the smallest thing we can build to find out?”
Reading a process diagram. In a flowchart, rectangles are steps, diamonds are decisions (“Is it fun?”) and arrows show the order. The arrows that point backward are where learning happens. When you draw your own, every diamond should have a “no” arrow that goes somewhere useful.
📖 Read for this lesson
The reading opens over the lesson; close it to come back to exactly where you were. The checks below draw on it.
Formative check
Work through these before moving on. They are not graded — they tell you whether the standard below has landed yet.
A team has every feature in the game working, though many are rough and some levels are missing. Which milestone have they reached?
The best time to discover that a core mechanic is not fun is during production, once the art is finished, because players can then judge the real game.
Draw the development pipeline as a flowchart with at least five steps and two decision diamonds. Mark every backward arrow with the kind of evidence that would send the team back. Then write one question you would want a prototype to answer for a game idea of your own.
How confident are you that you can describe the development pipeline and explain why it is iterative?
Practice
Work these on paper or in your notebook, then open Check your answer. Aim for all of Fluency and Application; try at least one Challenge.
Printable version: this unit’s practice workbook (PDF)
Fluency
Build speed and accuracy with the core skill.
- Put the five phases of game development in order: production, launch and live operations, concept, testing and polish, pre-production.
Check your answer
Answer: Concept, pre-production, production, testing and polish, launch and live operations.Studios name the phases differently, but most follow this shape, with testing sending the team back at every phase. - Define vertical slice and say which phase produces it.
Check your answer
Answer: A short section of the game built close to final quality to prove the team can make the rest. It is the most valuable output of pre-production.A prototype is rough and answers one question; a vertical slice is polished and proves the whole game is possible. - In a process flowchart, what do a rectangle, a diamond and an arrow each mean? What must every diamond have?
Check your answer
Answer: Rectangle: a step. Diamond: a decision (such as “Is it fun?”). Arrow: the order. Every diamond needs a “no” arrow that goes somewhere useful.The arrows that point backward are where learning happens.
Application
Use the skill in context. Show your reasoning.
- Name the phase or milestone: (a) all content is in and the team is mainly fixing bugs; (b) a few people write a pitch with the core verb, audience and hook; (c) a patch adds new levels after release; (d) a screen shake is added on impact and a coin sound is tuned.
Check your answer
Answer: (a) beta; (b) concept; (c) launch and live operations; (d) testing and polish.Alpha would be “every feature in, even if rough.” Polish is the difference between “it works” and “it feels good.” - Explain, using the lesson’s comparison, why designers test a core rule on paper rather than after forty levels are built.
Check your answer
Answer: Changing a rule on paper costs minutes; changing it after artists have built forty levels around it costs months. The design loop is cheapest early, so test ideas as early and as roughly as possible.Strong answers mention cost rising over time and the iterative cycle design, build, test, learn. - A concept is “a grappling-hook game for players new to platformers.” Write one question a prototype could answer, and describe the smallest thing you could build to find out.
Check your answer
Answer: Model answer: “Is swinging on the grapple fun for a new player within a minute?” Smallest build: one room with three grapple points and a gap, no art, no story.A good prototype question is specific and testable; the smallest build tests only that question. - A team’s task list has one card reading “Make level 2.” Why is that a poor card, and how would you rewrite it for a To do / Doing / Done board?
Check your answer
Answer: It is too big to finish in a day or two, so progress and problems stay hidden. Split it into small cards, for example “block out level 2 layout,” “place enemies in level 2,” “playtest level 2 once.”Teams break work into tasks small enough to finish in a day or two and meet briefly and often to surface problems early.
Review
Keep earlier skills sharp.
- Review (Lesson 1.4): what does a producer do, and why does that role matter in a pipeline with backward arrows?
Check your answer
Answer: A producer keeps the team on schedule and within budget, tracking tasks and cutting features that will not fit. When testing sends work back, the producer replans.The lesson pairs producers with tracking tasks and cutting features in production.
The Development Pipeline, Worked: A Four-Person Team, Its Gates and Its Backward Arrows
SLS original invented case; no real studio · SLS original
Why this reading. The launch lesson asks you to draw the development pipeline with the iteration loops marked and the evidence that sends a team backward. This is a worked case of one invented four-person team taking a game from concept to launch, with the decisions and the backward arrows written out, and a cost-of-change table so you can see why loops are cheap early. The team, dates and hours are invented for teaching (SLS original); no real studio is described.
Case: Dam Break, a four-person team
The team is a designer, a programmer, an artist and a producer, working 16 weeks. Their idea: two boats race across a river before a dam breaks (the rules appear in Reading 2.4).
| Phase | Weeks | Output | Gate question (the diamond) |
|---|---|---|---|
| Concept | 1 | One-paragraph pitch, three sketches | Do we know the core verb, audience and hook? |
| Pre-production | 2 to 5 | Paper prototype; Godot prototype of movement; one-page design document; schedule | Is the boat race fun with gray boxes? |
| Production | 6 to 12 | Levels, art, sound, systems; alpha at end of week 9 (all features in), beta at end of week 12 (all content in) | Do testers finish a level without help? |
| Testing and polish | 13 to 15 | Bug fixes, balance, screen shake, sounds | Is the crash count zero on the test list? |
| Launch | 16 | Release build, page, credits | Anything blocking release? |
Where the team went backward
- Week 4, prototype to concept. Evidence: in six paper games, no player chose to carry three seeds. Action: the designer changed the score rule and retested (this is the cheap loop).
- Week 8, production to pre-production. Evidence: in the Godot build, the boat controls felt sluggish to all three testers. Action: the programmer reopened the movement code for two days.
- Week 11, beta to production. Evidence: 4 of 5 testers could not finish level 3. Action: the designer cut two obstacles.
Cost of a change, by when it is found
| Where the problem is found | What must be redone | Hours (invented) |
|---|---|---|
| Concept, on paper | Erase and rewrite a rule | 0.5 |
| Paper prototype | Rewrite a card and replay once | 2 |
| Godot prototype | Change a script and re-test | 8 |
| After 40 levels are built around it | 12 hours per level x 40 levels | 480 |
The last row is 40 × 12 = 480 hours, which is 960 times the first row (480 ÷ 0.5). This is why the team tests the riskiest idea first.
Task board, week 6 (excerpt)
| To do | Doing | Done |
|---|---|---|
| Draw 12 river cards | Boat script | Track strip |
| Water marker art | Setup rules |
Your flowchart
Use rectangles for the phases and a diamond for each gate question above. Each diamond has a “yes” arrow forward and a “no” arrow back to the phase where the fix happens. Label each backward arrow with the kind of evidence (a playtest count, a tester quote, a crash count).