The whole pitch of an idle game is that it respects the time you are not playing. The genre rewards the closed app. So the architecture should match the pitch.
Most modern idle games on mobile do the opposite. They authoritatively gate progression behind a server. Lose signal in the elevator and the loop pauses. Lose the server entirely and the game ends.
Signal Decay is built offline-first. Here is the case for why.
What Offline-First Actually Means
Two definitions worth separating:
- Offline-tolerant. The app works without a connection by faking it. State drifts. Catch-up math runs on reopen.
- Offline-first. The simulation lives on the device. The server is the backup, not the source of truth.
The first is a network engineering problem. The second is a design decision that touches every system.
Signal Decay is the second one. Combat, crafting, gathering, shops, gem use: all local. Cloud sync is a five-minute background flush against a Supabase JSONB blob with optimistic locking. Twelve-hour offline progression cap on return.
The Player Contract
Idle games live or die on a single promise: the world keeps ticking when the app is closed.
A server-tethered idle game cannot make that promise honestly. It can only approximate it with a delta calculation on reopen. That works most of the time. It fails the moment the player needs it most: bad signal, airplane mode, server outage, account migration, app review window.
Offline-first inverts the failure mode. The server can go down for a week and your save still levels.
The Hidden Cost of Server-Authoritative Idle
Three costs nobody puts in the design doc:
- Latency on every interaction. Every swing, every craft, every shop click waits for a roundtrip. Idle games are click-dense in their active windows. The lag compounds.
- Anti-cheat tax. Validating every action server-side forces simplifications. Combat math gets dumbed down. Recipes flatten. Anything the server cannot replay in 50ms gets cut.
- Operational floor. You cannot release 1.0 until you can pay for the servers at scale. Indie idle teams die here.
Local simulation deletes all three. Combat math can be as deep as the device can run. Crafting graphs can branch as wide as the data fits. The marginal cost of a thousand more players is zero.
What You Give Up
Honest list:
- Trivial cheating. A motivated player can edit the local save. Signal Decay accepts this. Leaderboards and competitive modes need server validation. Single-player progression does not.
- Live events. Server-side events that mutate the world for everyone require a server. Offline-first games handle this with content drops in app updates instead.
- Cross-device sync feels different. Sync is a flush, not a stream. A five-minute window between devices is fine for an idle game. It would be wrong for a real-time shooter.
For a single-player idle RPG, the trade is one-sided.
Design Knock-Ons
Offline-first changes how you build systems, not just how you ship them.
Combat in Signal Decay is turn-by-turn in the foreground and pure simulation in the background. Same math, different presentation. The HP and combat XP commit per turn so the HUD updates live. When the app is closed, the simulation runs to the cap without rendering anything. The math is identical because the math has to be portable.
Crafting is deterministic. Recipes resolve from inputs, tool tier, and skill level. No server-side roll. The roll is local, reproducible, and the seed is your save.
Gathering scales to skill level on the device. Tool tier across four tool types modifies success and yield. The node table ships with the build.
The architecture forces the design to be honest. If a system cannot run on a phone in airplane mode, it does not ship.
Sync Without Tears
The naive sync model is "server is truth." That model fights offline-first.
Signal Decay uses optimistic locking on a JSONB save blob. The device writes, the server stores, the next read checks the version. Conflicts are rare in single-player and resolve to most-recent-write. The server never tells the device what its inventory is. The device tells the server.
This is the same shape Notion, Linear, and Figma use for collaborative state. It works for idle games for the same reason: the user's local copy is the one they care about.
The Twelve-Hour Cap
Offline progression has to cap somewhere. Otherwise a player who comes back after a year breaks the economy.
Signal Decay caps at twelve hours. Long enough to cover a sleep cycle and a workday. Short enough to keep daily players and weekly players in the same league.
The cap is a design lever, not a technical limit. The simulation could run for a month. The cap exists because compounding off-screen progress eats the active loop.
Why It Matters Now
Phones got fast. Storage got cheap. The case for thin-client idle games made sense in 2014. It does not make sense in 2026.
The player has a supercomputer in their pocket. Use it.
