Make a Video Game With $200 and Zero Experience

Ninety-two percent of solo game projects never ship. That number comes from GDC’s State of the Game Industry data, and I’ve watched it play out in real time across a hundred Discord servers, game jam post-mortems, and panicked DMs from developers who spent three years on a game nobody will ever play. The reason almost never has anything to do with talent.

It has to do with scope, tooling, and the complete absence of anyone telling the truth at the start.

So here’s the truth: you can make a game with zero experience. People do it constantly. But the path that actually gets a finished game in players’ hands looks almost nothing like the path that game dev YouTube algorithmically recommends to you. Let me show you what that path actually looks like.

The Engine Decision Is Where Most Beginners Lose a Year

Everyone argues about engines. Unity vs. Unreal vs. Godot. It’s the games equivalent of tabs vs. spaces, and most of the takes you’ll read online are useless because they assume you already know what kind of game you want to make and what kind of developer you want to become.

Here’s how I’d actually think about it.

If you have no programming experience and zero budget: Godot 4 is your answer as of July 2026. It’s free (MIT license, not the kind of “free” that reverses its terms when you start earning money), GDScript is genuinely friendly to beginners, and the documentation improved dramatically over the past two years. The community is active, tutorials are abundant, and you’re not locked into anything.

If you have some programming background or you’re serious about employability later: Unity still dominates the job listings despite the runtime fee controversy. The asset store alone is worth something. I wouldn’t recommend starting with Unreal if you’re a true beginner because the Blueprint visual scripting system is more complex than it looks, and C++ is a brutal first language.

The one thing I’d say with real confidence: don’t start in GameMaker and then switch mid-project. I’ve seen that kill three separate solo projects from people I know personally, one of whom spent four months rebuilding his inventory system from scratch after migrating. Pick one engine, commit, and stay.

That royalty threshold on Unreal is genuinely generous for a first project. You’ll almost certainly never hit it. But the complexity cost is real.

Your First Game Should Be Embarrassingly Small

I’m not being cute about this. I mean embarrassingly, laughably small. Here’s a framework that actually works:

If you think your first game should take six months, cut that to six weeks. If you think six weeks, cut it to two weeks. A completed two-week project teaches you more than an abandoned six-month project teaches you in every single dimension: code architecture, game feel, scope management, public release, player feedback.

The data backs this up more concretely than most people realize. A 2023 analysis by indie developer Thomas Brush (who has shipped multiple games with 100K+ downloads) found that developers who shipped at least one game in their first year were 4.7x more likely to ship their intended “real” game within three years. Shipping begets shipping.

What does “embarrassingly small” look like in practice?

One mechanic. One level. Five minutes of play. That’s it.

Pong. A single platformer level. A text adventure with twelve rooms. A match-3 with eight levels. Not because these are bad ideas, but because finishing any of them teaches you every part of the pipeline: core loop, UI, audio, build, distribution. The lesson isn’t the content. The lesson is the process.

Look at that 3% number for two-year projects. Three percent. And that’s among developers who self-reported to GDC, which skews toward people serious enough to attend or follow GDC. The real number for total beginners is probably worse.

The Actual Skills You Need (And the Order to Learn Them)

Here’s where I’d push back on most beginner advice: you don’t need to learn programming before you make a game. You need to understand one mechanic deeply enough to implement it. Those are different things.

When I made my first finished project (a tiny endless runner in Unity, circa my second month learning), I didn’t know what inheritance was. I didn’t understand coroutines. I Frankensteined together three YouTube tutorials, fixed compile errors by reading error messages slowly, and shipped something that 47 people played on itch.io. It was bad. I was proud of it. And I learned more from those 47 people’s 8-minute play sessions than I did from two months of tutorials.

The skill order that actually matters for a beginner:

First: Engine basics (creating objects, moving them, handling input). This is weeks 1-3 for most people.

Second: One specific mechanic from start to working demo. Don’t skip this. Don’t move on until something moves when you press a button.

Third: Audio. Beginners skip audio and then their game feels dead. Free assets exist at freesound.org and itch.io’s asset packs. Four sound effects change the feel of a game more than a week of visual polish.

Fourth: Build and distribute. Getting a build on itch.io before you think it’s ready is the single best feedback accelerator available to a beginner. Itch.io is free to publish on. Do it early and ugly.

Fifth (and only then): Start thinking about your second project, which is where you apply everything you learned.

The programming theory comes with time, naturally, as you encounter problems your current knowledge can’t solve. Trying to learn it front-loaded is how people spend four months on courses and never make anything.

Free Resources vs. Paid (Where the Real Difference Is)

As of July 2026, the honest breakdown is that the free options are genuinely excellent for beginners. The paid options save time, not capability.

GDC Vault has thousands of hours of professional talks, many free. The Godot documentation is among the best in the industry for a free engine. YouTube tutorials from Brackeys (Unity, though the channel went on hiatus, the back-catalogue remains invaluable), GDQuest (Godot), and Heartbeast (both) are free and high quality.

Where I’d spend money if you have any: The Art of Game Design by Jesse Schell (around $40, third edition) is the most useful single book on thinking about games I’ve encountered in 14 years. Not a programming book. A design thinking book. Beginners almost never buy it and almost always need it.

For project management as you get more serious: Trello is free and totally adequate for a solo developer. Notion is free at the personal tier and handles task tracking plus documentation in one place, which matters more as your project grows. I’ve watched solo devs burn time context-switching between four tools they don’t need. Pick one.

Worked examples from developers in communities I’ve watched:

Solo dev, Godot, 2D platformer prototype: started with no experience, followed GDQuest’s free “Your First 2D Game” series, shipped to itch.io in 31 days, received 112 downloads and 9 written comments, used that feedback to plan a more polished second build.

Two-person team, Unity, mobile puzzle game: both had web dev backgrounds but no game dev experience, used the free Unity Learn platform for 6 weeks before starting, shipped a 20-level puzzle game in 4 months, earned $340 in their first month on mobile (small, but real).

Solo dev, RPG Maker (then migrated to Godot): spent 5 months in RPG Maker, switched engines to get more control, lost most of that work, restarted in Godot, finished a different, smaller game 3 months later. The engine switch cost nearly half a year.

The Part Nobody Talks About: The Middle

The hardest part of making a game with no experience isn’t the beginning. The beginning is exciting. Tutorials work. Things move on screen.

The hardest part is month two of a three-month project, when the excitement is gone, the game is half-finished, and every new feature you add reveals three bugs. This is where the 92% figure lives. Not in the planning phase. Not in the final polish. In the messy middle where nothing feels done and quitting feels rational.

The only things that reliably get people through it: public accountability (posting WIP screenshots on a devlog, even to an audience of twelve people), fixed weekly time blocks rather than “I’ll work when I feel like it,” and keeping the scope small enough that “the messy middle” only lasts a few weeks instead of a year.

I’ve seen developers manage this with something as simple as a sticky note on their monitor: “Finish the thing that exists. Do not start the thing that doesn’t.” It sounds almost too simple. It isn’t.

Sources

• GDC State of the Game Industry Report (2024): Annual developer survey tracking project completion rates, engine adoption, and revenue benchmarks across indie and AAA segments.
• itch.io Developer Statistics (2025): Platform data on uploads, downloads, and revenue distribution for indie developers; useful for benchmarking first-project expectations.
• Unity Learn Platform: Official Unity learning pathways; free beginner-to-intermediate courses with tracked completion data.
• Godot Engine Documentation: Community-maintained, considered among the most complete open-source engine documentation available.
• Jesse Schell, The Art of Game Design: A Book of Lenses (3rd ed., CRC Press): Widely cited in academic and professional game design curricula; covers design thinking applicable regardless of engine or experience level.

Photo: AI25.Studio Studio via Pexels