Engineering, Note 01

How a one-person studio ships a polished mobile puzzle game.

What building, testing and maintaining Sudoku: Color looks like when one developer does all of it.

Nykylo Media is one developer. The code behind Sudoku: Color, ColorPair and Drag Tree Simulator was written, tested and submitted to the stores by the same person. That isn't a pitch; it's the constraint every decision below comes from. When there is nobody to hand work to, the question for any feature is not "is this good?" but "can I still maintain this in a year, alone?"

This note walks through how that plays out in the current version of Sudoku: Color, because it's the app with the longest history and the most moving parts.

Two versions of the same game

Sudoku: Color first shipped on the App Store as version 1.0 in May 2025, built in Unity. The Unity project uses Photon for multiplayer rooms and PlayFab for player accounts and leaderboards. The Google Play version that's live today comes from that Unity codebase.

Version 2.0, released on iOS in June 2026, is a different codebase: a native SwiftUI app targeting iOS 17. Multiplayer moved to Firebase Realtime Database, leaderboards moved to Game Center, and purchases moved to StoreKit 2. This note describes the differences between the two versions rather than the reasons for the rebuild — the point here is what the current structure makes possible for one person.

Keep the rules out of the app

The most useful structural decision in the native version is that the game's rules don't live in the app target. They live in a small local Swift package, SudokuKit, with no third-party dependencies. It owns the board model, the move and undo records, the solver, the puzzle generator, the seeded random number generator and the auto-notes engine.

That separation pays off in three ways for a solo developer:

  • It's testable without a simulator. SudokuKit has its own test target covering the board state, undo with notes, the generator, the solver, difficulty levels and the seeded RNG. Rules bugs get caught by a test run that takes seconds, not by playing a hundred games.
  • It's deterministic. The generator takes a seed. Same seed and same difficulty produce the same puzzle, which is what makes the daily challenge identical for everyone and lets a reported bad puzzle be reproduced exactly.
  • It's portable in principle. The UI layer can change without touching the rules, and the rules are written down in one place for anyone porting them to another platform.

Fewer services, each with one job

The app target is organised as a set of small services, each owning one concern: persistence, settings, the daily challenge, achievements, Game Center, purchases, ads, audio and multiplayer. They're all @Observable and main-actor isolated, and views read them from the environment. Nothing clever — the value is that when something breaks, there is one obvious file to open.

The same instinct shows up in what the app doesn't depend on. The only third-party packages are Google Mobile Ads and two Firebase modules (Core and Realtime Database). Achievements are local, stored on the device, rather than another backend to keep alive. Sound effects are synthesised at launch with AVAudioEngine, so there are no audio files to produce or license.

Write down the edge cases you already hit

The repository carries a long reference document describing how each system behaves and why. Most of it is a record of bugs that were found and fixed, written as rules so they don't come back. A few examples from multiplayer:

  • Joining a room claims the guest slot with a Firebase transaction, so two people entering the same code can't both join.
  • When both players finish at nearly the same moment, the winner is settled by a transaction on a single winner field: first write wins, and both devices show the stored result. Before that, two near-simultaneous finishes could both show "you win".
  • A full-screen rewarded ad triggers the same view lifecycle event as leaving the screen. The multiplayer view only forfeits a match if the navigation stack actually got shorter.

None of those are visible in a feature list. They're the difference between a game that works in a demo and one that holds up when real people use it at the same time.

Make the boring parts repeatable

Release work is where a solo developer loses the most time, because it's the work least worth remembering. A few things that are scripted rather than remembered:

  • A build runner script that builds the app, installs it on a chosen simulator and captures screenshots in light and dark appearance.
  • A StoreKit configuration file for testing both in-app purchases locally without touching the live store.
  • Store copy for every locale kept in a single file in the repository, with character counts noted against Apple's limits, so a release is a paste rather than a rewrite.

What "polished" means here

For a one-person studio, polish is mostly the absence of rough edges people would otherwise notice: a launch screen that hands off to the in-app splash without a visible jump, a saved game that survives the app being backgrounded, purchases that are recognised from the first frame after launch, a board that still fits when an iPad is in Split View. Each of those is a small, specific fix. Shipping a polished app alone is mostly a matter of finding them before players do, and writing them down once you have.

Note details

SectionEngineering
Reading time4 min
UpdatedOctober 18, 2026

Questions about something in this note?

Send a message. If you're weighing a similar decision in your own app or tool, a short description of the problem is enough to start.