From Idea to Published Level: A Creator's Full Workflow

🧭 Every published level starts as a messy idea, and almost every creator gets stuck at the same three points: scoping, playtesting, and actually hitting publish. This post is the map. It won't re-teach you every editor button or every hazard type — the deep-dive guides linked throughout already do that — but it will walk you through the full pipeline, start to finish, so you always know what stage you're in and what comes next.

Think of it as six stages: idea and scoping, building, characters and behavior, playtesting, publishing, and what happens after. Skipping a stage is usually what turns a promising level into one nobody finishes.

Stage 1: Idea and Scoping

Every level needs a constraint before it needs a layout. "A cool platformer level" is not a scope — "a 90-second vertical climb with one recurring hazard" is. Constraints force decisions, and decisions are what actually get built.

At this stage, settle:

• The core mechanic. One idea a player will recognize and repeat — a timing puzzle, a chase, a precision-jump gauntlet.
• Rough length and difficulty. Short and hard, or long and forgiving — pick one; hybrids are harder to pace well.
• 2D or 3D. This is a real fork in the workflow, not just a visual choice — 2D favors tight, readable platforming; 3D favors spatial exploration and verticality. If you're unsure which suits your idea, Getting Started with the 2D Editor and Getting Started with the 3D Editor both walk through what each editor is actually good at before you commit.

A level with a one-sentence concept is easier to finish than one with a paragraph of ideas. Scope down before you open the editor, not after you've placed fifty blocks.

Lokko's editors are free, browser-based, and need no download or account to start — which means scoping doesn't have to be a whiteboard exercise if you'd rather test an idea directly. Open the editor, block out a rough version of your concept in five minutes, and see if it's actually fun before you commit to it on paper.

Stage 2: Building the Layout

This is where the level becomes real. Start with the skeleton: platforms, paths, and the critical route from start to finish — not decoration, not hazards yet. A layout you can walk through cleanly (even if it's boring) is a much better foundation than a detailed section surrounded by empty space.

Once the skeleton is in place:

• Place your primary hazards or mechanics along the critical path first, then add secondary or optional ones.
• Keep an eye on pacing — a stretch of easy platforming after a hard hazard gives players a breather and makes the next challenge land better.
• Playtest the layout yourself as you go, not just at the end. Small "does this jump feel right" checks are cheap; discovering a broken jump after the whole level is dressed up is expensive.

The 2D and 3D editor guides linked above cover the specific placement tools and hazard types in full — this stage is really just about sequencing that work: skeleton, then critical-path hazards, then everything else.

Stage 3: Characters, NPCs, and Behavior

A layout with no characters in it can still be a fine level, but NPCs are usually what turn a level from a course into a place. Once your layout is stable, this is the natural point to add them — building NPCs into an unfinished layout usually means moving them again later.

• Design the character first, then its behavior. If you don't want to touch 3D modeling, How to Make a Game Character Without 3D Modeling covers building a recognizable character using 2D tools and techniques.
• Give NPCs a job. A guard that patrols a specific stretch, a guide that points toward the next hazard, a boss that gates the level's climax — behavior should reinforce what the layout is already doing, not fight it.
• Lokko's NPC editor exists specifically for this kind of behavior-driven design, and Designing an NPC Editor for Kids goes into the thinking behind making that kind of tool approachable for younger creators — useful context even if you're not a kid, because it explains why NPC behavior in Lokko is built the way it is.

Stage 4: Playtesting and Iterating

This is the stage most creators are tempted to skip, and it's the one that matters most. A level that's completable by you — the person who placed every block — is not the same as a level that's completable, and fun, for someone seeing it cold.

• Play it fresh. Step away, come back, and run it as if you'd never seen it before. Note every moment of hesitation.
• Watch someone else play it, if you can. Where they pause, where they die repeatedly, and where they stop paying attention are all information you can't get from your own playthrough.
• Fix the biggest problem first. One unfair hazard or one confusing path is usually worth more of your time than five small polish tweaks.

The gap between "I can finish this level" and "a stranger can finish this level" is where most of the real design work happens. Budget time for it — don't treat it as an afterthought before publishing.

Iterate in small passes: adjust, retest, adjust again. A level rarely needs a rebuild — it usually needs two or three targeted fixes.

Stage 5: Publishing and Sharing

Once your level plays the way you want, publishing is the easy part — but a little intention here makes a level easier for other players to find and choose. Publishing and Sharing Your Level covers the mechanics of the publish flow in full; the short version is that a clear title, a short honest description of what to expect, and picking the right tags all make a real difference in whether players click in.

Levels you publish become part of Lokko's user-generated content ecosystem — browsable, playable, and discoverable by anyone. If you want a sense of why UGC-driven creation has become such a central part of how games grow, The Rise of User-Generated Content in Games puts the current publish-and-share loop in that wider context.

Try the 2D Editor

Stage 6: After Publish — Watching and Responding

Publishing isn't the finish line — it's closer to the start of a second, quieter loop. A published level keeps generating information: play counts, completion patterns, comments, and reactions from players you'll never meet directly.

• Watch how players actually move through it. If a spot trips up many different players, that's a design signal, not bad luck.
• Read feedback with a filter. One frustrated comment isn't a verdict; a pattern across several is.
• Ship small updates rather than a total rebuild. A tweak to one hazard or one checkpoint is often all a level needs after real players have tested it at scale.
• Share it beyond the platform. Posting a clip or asking for feedback in Lokko's Discord or on YouTube can surface the kind of detailed, specific reactions that in-game comments rarely give you.

Treat every published level as a draft that's live, not a finished product that's done. The creators who keep iterating after publish are almost always the ones whose levels keep climbing in plays over time.

Key Takeaways

• Scope before you build — one clear mechanic, a rough length, and a 2D-vs-3D decision save far more time than they cost.
• Build the skeleton first, then critical-path hazards, then everything secondary.
• Add NPCs and behavior after the layout is stable, so their placement supports a level you already understand.
• Playtest deliberately — your own fresh eyes, and ideally someone else's, before you publish.
• Publishing is a milestone, not an ending — a clear title and description help players find your level, but watching reception and iterating afterward is where levels keep improving.
• Lokko's free, browser-based 2D and 3D editors and NPC editor support this entire pipeline without a download or account, so there's nothing stopping you from starting at Stage 1 today.

Start Building in Lokko

Curious how we got here? Our short history of level editors traces this workflow's lineage all the way back to 1983. Or see what this workflow actually produces in our roundup of community-built levels worth playing this month.

Not sure which input to build with? See touch vs. gamepad vs. mouse for how they actually compare. And once your level is live, here's exactly how to share it with a friend on a different platform.

Curious how player feedback actually shapes this pipeline? See what Early Access feedback changed about our game, with real quotes from the public feedback dashboard.