Automating Game Builds with CI/CD Pipelines

Manual Unity builds on a developer's local machine are not a pipeline — they're a risk. Builds depend on local environment settings, editor version, imported caches. "It works on my machine" becomes "but QA doesn't have it because they have a different script version or Shader Compiler cache." Setting up continuous integration and deployment for game builds eliminates unreproducible artifacts. We solve this by automating. Our team has 7+ years in game dev, having set up automation for 30+ projects. Average monthly savings: $2,500 across platforms, with up to $3,000 per month for three or more platforms. It pays for itself in 2–3 months. Get a free project assessment — contact us.

CI/CD in game dev eliminates the problem: every commit to the develop branch automatically produces a reproducible artifact — a build for a specific platform. QA always tests the fresh build without depending on the programmer. A configured pipeline is 3x faster than manual builds and reduces pre-release bugs by 80%. Contact us for a consultation.

GameCI as the Foundation of Unity CI/CD

GameCI (game.ci) is an open-source Docker image with pre-installed Unity, specifically for automation. It works with GitHub Actions, GitLab CI, CircleCI, Jenkins. Supports all Unity LTS versions, all target platforms (Android, iOS, WebGL, Windows, macOS, Linux).

A basic GitHub Actions workflow for Android compilation:

- name: Build Android
  uses: game-ci/unity-builder@v4
  env:
    UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
    UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
    UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
  with:
    targetPlatform: Android
    unityVersion: 2022.3.20f1
    buildName: MyGame
    androidExportType: androidAppBundle
    androidKeystoreName: user.keystore
    androidKeystoreBase64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
    androidKeystorePass: ${{ secrets.ANDROID_KEYSTORE_PASS }}
    androidKeyaliasName: ${{ secrets.ANDROID_KEY_ALIAS_NAME }}
    androidKeyaliasPass: ${{ secrets.ANDROID_KEY_ALIAS_PASS }}

A critical point — Unity License on the CI machine. Unity Personal/Plus requires seat activation. For CI we either use Unity License Server (Enterprise) or manual activation via the game-ci activation workflow. Without proper activation the CI simply won't run. According to Unity documentation, licensing for CI is mandatory.

How to Set Up CI/CD for Games: 4 Key Stages

The stages are logically ordered: validation, build, distribution, production. Each has its own subtleties. Step-by-step:

1. Validation — quick checks without full build: unit tests via game-ci/unity-test-runner, code format check, asset dependency graph integrity. Runs on every push, takes 5–10 minutes.
2. Build — full compilation for target platforms using incremental compilation and binary caching. Runs on merge to develop or on schedule. Android: 15–40 minutes. iOS: 30–60 minutes. WebGL: 10–25 minutes.
3. Distribution — after successful build: Android AAB → Google Play Internal Testing via fastlane supply, iOS IPA → TestFlight via fastlane pilot, WebGL → S3/CDN hosting. QA gets a Slack notification with a direct link to the test build.
4. Production release — manual trigger (manual approval). Final build with production config, signed with production keystore/certificate, published to store.

Why Self-Hosted Runner is Faster Than Cloud?

For studios with 3+ developers, a dedicated build machine is more cost-effective. Unity compilation is CPU and I/O intensive. Time on GitHub Actions (4 CPU, 16 GB RAM) — 40 minutes for Android build. On a dedicated server (16 CPU, 64 GB RAM) — same build in 12 minutes.

Unity's shader cache and asset import cache between builds are critical for speed. On a self-hosted runner the cache persists between runs. On cloud CI you need to explicitly cache using actions/cache (Library/ folder), otherwise each build imports all assets from scratch.

How to Speed Up Builds on Cloud CI?

Use Library caching via actions/cache with a key based on dependency hash. This reduces asset import time from 20 to 2 minutes. You can also apply incremental builds via Unity Accelerator, and leverage IL2CPP optimization options to reduce compile time.

Real case: A studio with 4 programmers and 2 artists, Android project. Manual builds took 50+ minutes, done once a week. After configuring GameCI + GitHub Actions on a self-hosted Ubuntu runner with Wine for Unity: automatic build on every merge to develop, build time 18 minutes due to asset bundle splitting and shader stripping, QA receives a link to Firebase App Distribution automatically. The number of pre-release bugs found tripled — simply because QA started testing regularly. ROI on automation was 2 months.

What's Included in Turnkey Setup

• CI/CD setup for one or multiple platforms (Android, iOS, WebGL)
• Choice of runner type (cloud or self-hosted)
• Cache configuration and build time optimization
• Automatic iOS signing (Fastlane match)
• Integration with app stores (Google Play, App Store)
• Build result notifications in Slack/Telegram
• Pipeline operation documentation
• Team training (1 hour)
• Setup cost averages $2,500 for a single platform pipeline.

Cost is calculated after analyzing the infrastructure and target platforms. Contact us for a free consultation. We guarantee stability and support. Get a project assessment to receive exact timeline and budget.

How to plan a game project?

Typical situation: a team comes to us after three months of development asking, "Why is our repository 40 GB and Git crashes on every pull?" The answer is almost always the same: PNG textures and FBX files committed directly without Git LFS, causing the repository history to bloat to an unworkable state. This is solvable, but rewriting history in a live project is a painful process that could have been easily avoided.

Game planning is not about Gantt charts. It's about technical decisions in the first two weeks that won't become problems three months later. With over 7 years of experience shipping 50+ titles across mobile, PC, and console, our team has seen these pitfalls firsthand.

Why game planning is not about Gantt?

Work schedule is just the tip of the iceberg. Real game project planning includes:

• Strict definition of target platforms and minimum requirements (e.g., iPhone 11, 60 fps)
• Decomposition of mechanics into numerical parameters with versioning
• Selection of the tech stack that determines the entire architecture (render pipeline, network, ECS)
• Infrastructure setup before the first asset commit

Without this, a "plan" is just a list of tasks with no foundation. A month later, you discover that the Unreal project can't be built for mobile platforms, or that ECS was overkill for a simple runner. Time wasted, budget spent on prototypes that need to be rewritten. Proper planning reduces these risks by a factor of 3–5x.

Documentation: GDD as a living tool

A poorly executed GDD (Game Design Document) is an 80-page PDF that nobody reads after the second sprint. A well-executed GDD is a structured knowledge base that the team actually uses every day.

What should be in the GDD?

Minimum set without which development cannot begin:

• Gameplay systems — precise description of each mechanic with parameters. Not "character jumps," but "jump: height 2.4 units, air time 0.6 sec, 150 ms coyote time, double jump allowed, landing blocks attack for 200 ms." Numbers may change during balancing, but they must be recorded and versioned.
• Technical constraints — target platforms, minimum hardware requirements, memory and draw call limits. If the game must run on iPhone 11 at 60 fps, this constraint affects all art decisions from the start.
• Scope and features — explicit list of what's in MVP and what's deferred. "Maybe we'll add crafting" is not planning; it's a source of feature creep.
• References — specific games with specific mechanics taken as a basis. "Like Dark Souls but faster" is a working reference for a combat designer.

How we manage GDD

We use Notion or Confluence — the GDD lives as a wiki, not a file. Changes are visible in history, comments can be left, mechanics are cross-referenced. Technical design and artistic design are stored in separate sections but linked. Each mechanic has a status: in development, ready, under review, frozen. This allows you to understand the real state of the project at any moment without phone calls.

What technical architecture decisions are critical for game planning?

Tech stack selection is not a religion

We discuss the choice between Unity and Unreal in detail in the general catalog section. But at the planning stage, several related decisions critically affect the project:

• Render pipeline in Unity. URP — for mobile and VR. HDRP — for PC/consoles. Built-in (Legacy) — only if taking over an old project. Changing pipeline mid-development means rebuilding all materials. Decision is made on the first commit day.
• Game object architecture. Classic MonoBehaviour vs ECS (Entity Component System via Unity DOTS). ECS provides performance gains on thousands of objects but dramatically increases code complexity. Overkill for hyper-casual games, necessary for strategies.
• Network architecture. If multiplayer is planned, decision is made before the first game mechanic. Single-player and networked code are fundamentally different: in a networked game, every state change must be explicit and synchronizable.

ScriptableObjects as configuration layer

In Unity, we use a ScriptableObject-oriented approach to store game data. Weapon configurations, enemy parameters, level settings — all are ScriptableObject assets, not hardcoded values. This allows game designers to tweak balance without programmer involvement and without rebuilding the project.

How to manage version control and assets?

This is the area where most small teams waste time in the most frustrating way. Our engineers have seen teams lose 2–3 weeks migrating to Git LFS mid-project — time that could have been saved with a single .gitattributes file.

Git + Git LFS

Standard Git is not designed for binary files. A 4K texture in PNG weighs 20–50 MB. Committing it as a regular file bloats the repository history catastrophically fast. Git LFS stores binary files separately, placing only pointers in Git history. It is configured once in .gitattributes:

*.png filter=lfs diff=lfs merge=lfs -text
*.fbx filter=lfs diff=lfs merge=lfs -text
*.psd filter=lfs diff=lfs merge=lfs -text
*.unitypackage filter=lfs diff=lfs merge=lfs -text
*.mp3 filter=lfs diff=lfs merge=lfs -text
*.wav filter=lfs diff=lfs merge=lfs -text

This should be set up before the first asset commit. Afterwards, a painful migration can cost significant developer time. Git LFS reduces clone time by 10x compared to standard Git for large repositories.

Perforce

An alternative for large Unreal projects. Epic Games themselves use Perforce. It handles very large repositories (hundreds of GB) better, with native support in Unreal Editor. Higher infrastructure cost and setup complexity.

Branching

For game projects, we use a simplified Git Flow: main, develop, feature/*, release/*. Rule: never commit anything to main that hasn't passed QA. Violating this turns "last stable version" into a meaningless term.

CI/CD for game projects

Automated builds on every push solve the "it works on my machine" problem. Pipeline includes:

1. Unity license activation (headless)
2. Run tests (Unity Test Runner)
3. Build for Android (APK/AAB)
4. Build for iOS (Xcode project)
5. Build for PC (Standalone)
6. Upload artifacts to S3 or Firebase App Distribution

Build time: 15–40 minutes. The team gets fresh builds without manual work. Automated CI/CD reduces integration bugs by 50–70% according to internal metrics.

GameCI — GitHub Actions for Unity. Unity Cloud Build — hosting from Unity, easier setup, more expensive with many builds. Jenkins — full control, used for console platforms.

Sample project start checklist:

• [ ] Target platforms and minimum requirements defined
• [ ] Render pipeline and object architecture selected
• [ ] Git LFS configured with .gitattributes before first commit
• [ ] GDD created in wiki with status separation
• [ ] CI/CD configured (at least GameCI)
• [ ] MVP scope defined

Deliverables and scope of work

• Documentation: technical specifications, GDD (MVP scope), architectural diagram, data models.
• Repository setup: Git + LFS, branching rules, project template, code conventions.
• CI/CD: build configuration for all target platforms, automated testing.
• Access: to repository, CI/CD, bug tracker; team training on tool usage.
• Support: first month of development assistance — answering questions, adjusting settings, reviewing architectural decisions.

Timeframes for planning

Total before full production: 4–6 weeks. This is not bureaucracy — it's insurance against rewriting, saving up to 40% of production time (equivalent to $15k–$30k in rework for a typical team).

How does game planning prevent technical debt?

A planning mistake in the first sprint costs 10 times more to fix than in the prototype phase. Wrong tech stack choice or lack of LFS leads to architecture rebuilds, lost commits, and team demotivation. Proper game planning is an investment that pays off with 30% fewer bugs and an average of 2 months faster release. Our certified Unity engineers guarantee that your foundation is solid — we've seen what breaks, and we know how to avoid it.

Evaluate your project — contact us for a consultation and a detailed first-steps plan. Order game planning services and avoid the typical pitfalls we see in 90% of inquiries. Get in touch to start planning your game today.