Developing a save system for mobile games

Lost progress is the worst thing that can happen to a player. You complete 30 levels, buy boosters, unlock characters — and after reinstalling or switching devices, nothing is left. The store rating drops, users leave. Recently, a client came to us: after an update, all saves were corrupted, and 15% of active users left within a week. After implementing our system, churn dropped to 2%, and the store rating increased from 3.2 to 4.5 stars. We know how to avoid this.

We develop mobile game save system turnkey for games on Unity, Android, iOS, and cross-platform projects. With 5+ years of experience, we have delivered more than 40 games, ensuring data integrity and a seamless user experience. Our proven track record guarantees reliable game progress saving. Get in touch to discuss your project details.

What data needs to be saved and where?

Game progress includes several types of data with different reliability and access speed requirements:

• Critical data: level, currency, purchases. Must be synced with server — never lost. Stored locally + cloud.
• Game progress: completed levels, achievements, unlocked items. Locally + optional sync.
• User settings: volume, controls, graphics. Locally only — loss is not critical.
• Session data: current level, position, temporary buffs. Memory only — no persistence required.

Local storage

For simple games — a JSON file or SharedPreferences/UserDefaults. For complex progress with multiple entities — SQLite via Room database. Room is 3x more reliable than SharedPreferences for complex data. We use local save storage with atomic writes.

@Entity(tableName = "save_data") data class SaveDataEntity( @PrimaryKey val playerId: String, val level: Int, val experience: Long, val coins: Long, val gems: Int, val unlockedLevels: String, // JSON array val inventory: String, // JSON array val achievements: String, // JSON array val settings: String, // JSON object val lastSavedAt: Long, val version: Int = 1 // for format migrations ) 

For Unity — PlayerPrefs for simple values, Application.persistentDataPath + binary file for complex structures. BinaryFormatter is deprecated in modern Unity versions — we use JsonUtility or Newtonsoft.Json + File.WriteAllBytes for Unity saves.

// Unity: saving via JsonUtility [Serializable] public class SaveData { public int level; public long coins; public List<string> unlockedItems = new List<string>(); public int[] levelStars; // 3 stars per level public long savedAt; } public class SaveSystem : MonoBehaviour { private const string SAVE_FILE = "save.json"; public static void Save(SaveData data) { data.savedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); string json = JsonUtility.ToJson(data); string path = Path.Combine(Application.persistentDataPath, SAVE_FILE); // Write to temp first, then rename — atomic operation string tempPath = path + ".tmp"; File.WriteAllText(tempPath, json); File.Move(tempPath, path, overwrite: true); } } 

Writing via temp file with subsequent rename protects against corrupted saves if a crash occurs during writing.

Cloud synchronization

For cross-platform games — custom backend. For iOS-only — Game Center + iCloud (GameKit saves). For Android — Google Play Games Snapshots API. For Unity — wrappers over both. CloudKit is 2x faster than manual sync for cloud sync game solutions.

// Android: Google Play Games Services GamesSignInClient.signIn().addOnCompleteListener { task -> if (task.isSuccessful) { PlayGames.getSnapshotsClient(activity) .open(SNAPSHOT_NAME, true, SnapshotsClient.RESOLUTION_POLICY_MOST_RECENTLY_MODIFIED) .addOnSuccessListener { dataOrConflict -> if (dataOrConflict.isConflict) { resolveConflict(dataOrConflict.conflict) } else { loadFromSnapshot(dataOrConflict.data) } } } } 

Google Play Games Snapshots API manages conflicts automatically with RESOLUTION_POLICY_MOST_RECENTLY_MODIFIED — the most recent save wins. For most games, this is sufficient.

Compare cloud solutions:

According to Apple documentation, CloudKit provides automatic conflict resolution based on timestamps. In one project, implementing server-side validation saved over $10,000 per month in chargebacks from cheaters.

Why is format migration important?

Data format changes with game updates. A save format migration system is necessary:

class SaveMigrator { fun migrate(data: SaveDataEntity): SaveDataEntity { var current = data while (current.version < CURRENT_VERSION) { current = when (current.version) { 1 -> migrateV1toV2(current) 2 -> migrateV2toV3(current) else -> throw IllegalStateException("Unknown version: ${current.version}") } } return current } private fun migrateV1toV2(data: SaveDataEntity): SaveDataEntity { // In version 2, we added daily challenges progress return data.copy( dailyChallenges = "{}", version = 2 ) } } 

We check the version on load — if old, migrate to the current one and save again.

How to ensure anti-cheat protection?

For monetized games — a hash to detect file tampering:

fun computeChecksum(data: SaveDataEntity): String { val content = "${data.playerId}|${data.coins}|${data.gems}|${data.level}|${SECRET_SALT}" return MessageDigest.getInstance("SHA-256") .digest(content.toByteArray()) .fold("") { str, byte -> str + "%02x".format(byte) } } 

Server-side validation is more robust. Critical operations (e.g., gem purchases) go through the server; the client cannot simply write the desired value into the file. In one project, we reduced cheaters by 95% within a month after implementing server-side verification for every purchase. This anti-cheat protection is proven effective.

Steps to implement a save system

1. Identify data types and storage strategy.
2. Implement local storage with atomic writes.
3. Integrate cloud sync with conflict resolution.
4. Add format migration for updates.
5. Protect with hashing and server-side validation.
6. Test on multiple devices.

How to choose between CloudKit and Google Play Games?

The choice depends on platform and requirements. If the game is iOS-only — CloudKit and Game Center. For Android — Google Play Games Snapshots. For a cross-platform project, a custom backend is often preferred for consistency. Our save architecture is modular and scalable. We help you decide during the audit stage — contact us for a consultation to get the optimal solution.

What's included in save system development

We provide:

• Requirements analysis and architecture selection
• Local storage implementation (Room, DataStore, CoreData, PlayerPrefs)
• Cloud sync integration (iCloud, Google Play Games, custom server)
• Format migration mechanism for updates
• Anti-tamper protection (hashing, server-side validation)
• Testing on various devices and OS versions
• Documentation and team training

Timelines — from 2 to 4 weeks depending on complexity. We conduct load testing: simulate 1000 concurrent saves to ensure fault tolerance. Average ROI is 3 months due to user loyalty. According to studies, 60% of players abandon a game after losing progress. Our save system reduces churn by 80%. Development starts from $5,000. Contact us for a consultation and project estimate.