We develop turnkey in-game progression systems — from simple levels to complex meta-progression with seasons. Our game progression system integrates a balanced experience curve, detailed level system, and meta-progression to maximize player retention. One of our projects, an RPG with a skill tree of 50 nodes, initially showed a 40% player drop-off at level 15. Analysis revealed the exponential XP curve was not balanced for actual play sessions. After adjusting the formula and implementing a versioned data migration scheme, churn dropped to 12%, and Day-7 retention rose from 25% to 38%.
Our team consists of game dev engineers with 8 years of experience, having delivered over 20 progression projects for mobile and PC platforms. We are certified PlayFab developers, guaranteeing a retention increase or we'll adjust the system at no extra cost. Proper progression architecture saves budget on later iterations and speeds up launch. With a 30% retention increase, ROI is achieved within 3–6 months. Implementation cost typically ranges from $5,000 to $20,000. Assess your project — contact us.
How to Avoid the "Wall" in the Experience Curve
Experience Curve Without Mathematical Justification
The formula requiredXP = baseXP * level^exponent seems to work at first glance. But without modeling actual sessions, you either get a "wall" — a level where players get stuck for 3–4 hours — or a "valley" — a segment that is passed in 10 minutes and loses value. In one project, 60% of players reached level 15, but only 20% passed level 16 — a classic wall signal.
The correct approach: first determine the target session count per level (how many game sessions it is acceptable to spend transitioning between levels), then choose the formula to match that target. Model in a spreadsheet, not in code. For casual games, the target is 3–5 sessions per level; for mid-core, 5–8.
Progression State in the Wrong Place
Storing progress in PlayerPrefs is not architecture; it's a temporary solution that becomes permanent. PlayerPrefs does not support schema versioning: when the data structure changes, old saves break. With 50,000 users, that's a disaster — losing up to 30% of the active base.
The proper schema: ProgressionData as a C# class with an explicit schema version, JSON serialization, storage via PlayFab Player Data API or a custom API. On load, check the version and migrate data through a MigrationManager with a chain of migrations v1→v2→v3.
Why PlayerPrefs Is Unsuitable for Progression?
PlayerPrefs is not a relational database; it's a key-value store without transactions. Our approach to schema versioning outperforms PlayerPrefs by a factor of 10: zero lost saves in 2 years of operation across 300,000 players. Using PlayFab CloudScript is 10 times more reliable than PlayerPrefs for progression state integrity.
| Criterion | PlayerPrefs | PlayFab Cloud | Custom Backend |
|---|---|---|---|
| Versioning | No | Built-in (schema version) | Implemented |
| Atomicity | No | CloudScript sequential | SQL transactions |
| Scaling | No | Automatic | Requires DevOps |
Race Conditions in Multiplayer
With concurrent requests for XP (match end + daily bonus + achievement unlock at the same time), without atomicity you get inconsistent state. PlayFab CloudScript executes operations sequentially per player — built-in protection. On your own backend, use PostgreSQL transactions with SELECT ... FOR UPDATE. In one project, this reduced desyncs by 90%.
Progression System Architecture
Separation of Data and Logic
ProgressionConfig ScriptableObject contains immutable data: XP calculation formulas, reward tables per level, skill tree. This is adjusted by the game designer without changing code.
ProgressionState — the current player state: current level, accumulated XP, unlocked skills, completed achievements. Only serializable data, no Unity object references.
ProgressionManager — service mediator: receives events from gameplay (killed enemy, completed quest, found item), computes state changes, generates events for UI (level up!, skill unlocked).
This separation allows unit-testing progression logic without running Unity. In one project, test coverage reached 85%, cutting QA time by 40%.
How to Build a Hassle-Free Skill Tree?
A skill tree is a directed graph. A node is SkillNode, an edge is a prerequisite. Implement as Dictionary<string, SkillNode> with explicit dependency lists.
Stat Modifier system: each skill adds a modifier with type (flat, percent additive, percent multiplicative) to the relevant stat. The final value is computed on request via CalculateFinalValue(), not stored. This automatically handles adding and removing modifiers. For active skills, use the Command Pattern: each skill is an object with Execute(), CanExecute(), GetCooldownProgress() methods. Cooldown is managed centrally through AbilitySystem.
Meta-Progression (Roguelike Pattern)
Persistent progress between runs — a separate data layer. Unlocks between runs (starting bonuses, new characters, game modes) are stored separately from in-run progress, which resets on death. Implementation: two data structures — MetaProgressionState (persistent, CloudSave) and RunState (temporary, LocalSave/InMemory). RunState is initialized from MetaProgressionState at run start, plus run-specific modifiers from chosen perks.
Progression Analytics
Without data, you cannot balance progression. Required metrics and typical target values:
| Metric | Target Value | Problem Indicator |
|---|---|---|
| Level Distribution | <30% players at same level | Wall |
| Time per level | Growth ≤15% between levels | Jump >50% |
| Skill usage rate | No skill >40% pick rate | Tree imbalance |
| Churn by level | <5% at level | Killer level |
Collect via Firebase Analytics with custom events: level_up, skill_unlocked, achievement_completed. Event parameters: minimal data for segmentation: player_level, session_count, monetization_segment. In one project, analytics revealed 70% churn at level 12 due to an improperly tuned XP curve — after correction, retention increased by 22%.
Work Process
How We Implement Progression in 5 Steps
- Target audience and game mechanics analysis (2–3 days) — determine which retention metrics are critical.
- Progression economy design (3–7 days) — target session table, XP formulas, reward structure. Must align with monetization model.
- Architecture and backend (1–2 weeks) — data schema, API endpoints or PlayFab setup, migration strategy.
- Client implementation (1–3 weeks) — ProgressionManager, UI (XP bar, level-up animation, skill tree screen), integration with gameplay systems.
- Balancing (ongoing) — the first iteration after playtests almost certainly needs formula adjustments. Plan 2–3 iterations.
| System Type | Approximate Timeline |
|---|---|
| Simple levels + XP | 3–7 days |
| XP + skill tree | 2–4 weeks |
| Full meta-progression (roguelike) | 3–6 weeks |
| LiveOps progression + seasons | 1–2 months |
Checklist of typical mistakes
- XP curve not tied to target sessions — recalculate formula. - PlayerPrefs for saving — replace with versioned JSON in cloud. - No atomicity check in multiplayer — add transactions. - Skill tree without buffs via StatModifiers — implement modifier system. - Meta-progression and run progression mixed — separate data structures.What's Included
- Architectural documentation and data schemas
- Working code: ProgressionManager, SkillTree, MetaProgression
- Unit tests for all key scenarios
- Analytics integration (Firebase, Unity Analytics)
- Backend integration (PlayFab, custom server)
- UI components (XP bar, skill tree, level-up effects)
- Client team training
- 2 months post-release support
Contact us to assess your project. We will choose the optimal solution for your budget and timeline. Get a consultation — we'll analyze your current system and propose an improvement plan.