What Does Your Build Pipeline Cost You?
Do you know how much it costs you to not think about your build pipeline?
Most small teams don’t, and for a good reason: they are busy making the game. But build times grow slowly, and maybe you never even created a build before, and soon you accept the one hour it takes. This case study shows you what long builds really cost, and how designing a content pipeline brought it down to a few minutes on a narrative-driven Unity game.
The project
The game is small in scope and rich in content: a narrative-driven title with a large amount of text but also graphical and audio media. My role as programmer was, besides UI and minigame work and tech art tasks, to help ship the game. I was the freelance expert, brought in to address where the team got stuck.
The team had put its energy where it belonged, into writing, art and making the game work. The build setup was the Unity default: everything in one project, in one repository. That is the right way to start, and it works well until the content comes in.
Where the hours went
A build for a single platform took over an hour, and multiplied in three scenarios.
- Builds. Every build processed all media again, whether it had changed or not. And although the project used Unity’s Addressables, those also got rebuilt every time.
- Re-imports. The team was relatively new to Git, and problems while merging were unavoidable. So, the reliable fix was to wipe the Library folder and re-import. This happened several times, on several machines. Unity’s import step took about as long as a build.
- Platforms. Shipping on several platforms means switching, testing and fixing on each one. Every iteration on every platform added another hour.
None of this is a mistake by any one person. It is what a default setup does.
The cost in numbers
The waiting adds up to a simple multiplication.
An illustrative example, not the project’s actual figures: 4 people, each hitting 3 one-hour waits a week, at a blended rate of 50 EUR per hour. That is 12 hours and 600 EUR a week, or about 2,600 EUR a month, for waiting alone.
They might or might not be blocked in that time, and might or might not be paid for it, but people also lose focus during an hour-long wait, avoid testing because it is expensive, and find platform bugs late. In the shipping and fixing stage, when you try to take your last steps over the finish line, you easily lose the most money.
The approach: a content pipeline
The fix starts with the question of which content really needs to live in the game project, and which does not.
Before: one project
- One repositorycode, UI and all media
- Unity importabout an hour
- Build per platformover an hour
After: content pipeline and game project
- Content repositorynarrative content and media
- Content buildruns when content changes
- Addressables bundlesbuilt once, ready to download
downloaded by the team
- Game repositorycode, UI and features
- Unity importa few minutes
- Build per platforma few minutes
The media is built once in its own process and the game project only downloads the result. Here are the necessary steps:
- Separate. The structured game content and its media moved out of the main repository into a content repository. The game project keeps code, UI and features, with no media to import.
- Build once. The content is built into Addressables bundles in a separate process. It only runs again when content changes, and finished content rarely does.
- Download. Anyone testing the game itself, not the content, downloads the prebuilt bundles. That is fast and cheap.
- Build the game. The main build now contains only the game, so it finishes in minutes.
I share the tooling as a Unity package on GitHub: Content Repo. It checks out only the content folders each developer needs, builds them into Addressables bundles and uploads them to a CDN. I also included a first implementation for AWS (S3 and CloudFront). In earlier projects, I had the same setup running on Firebase or on self-hosted servers.
Results
Builds and re-imports went from about an hour to a few minutes.
| Before | After | |
|---|---|---|
| Build, one platform | Over an hour | A few minutes |
| Library re-import | About an hour | A few minutes |
| Content processing | Part of every build | Separate, only when content changes |
| Testing a game change | Full build first | Download bundles, then a short build |
A broken Library folder stopped being a lost morning. Testing on a second or third platform became routine instead of something to postpone. And I really loved the magical moment when the team discovered how smooth this can be.
Man, builds are so fast now. After the old setup I was scared to do them, but that was quick.
The side benefit
Splitting the pipeline forces a cleaner design: game features and UI on one side, structured game content on the other.
Once that line exists, programmers can change features without touching content. At the same time, writers and artists can still check out the exact episode they work on without needing all other episodes. The two sides meet at a defined format instead of in the same folders, which also removes many of the merge conflicts.
The player side
There are also benefits for players and for user acquisition. A build that holds the whole project is one huge file. On mobile, the download size alone loses some players before they start. Someone who only wants to try the beginning still has to download everything. And updates often mean downloading large parts of the game again.
With the content in bundles on a CDN, the game downloads content when the player gets to it. The beginning is playable sooner, and an update only ships the bundles that changed.
A shared cache server
A shared cache server like Unity Accelerator is a good addition to a content pipeline. It caches imported assets, compiled shaders and compressed textures. A re-import, a first project open or a build can then download those results instead of computing them again.
Unity gives you the software, but you host it yourself. For a remote team, you need to consider the following:
- A server. A machine in the office or a cloud server from any provider, with fast storage for a copy of the Library folder per platform and active branch.
- A private network. The Accelerator has no access control. Unity recommends running it behind a VPN or a restrictive firewall.
- A plan for mix-ups. Every machine uploads by default. If an import goes wrong on one machine, the cache hands that result to the whole team. Unity suggests that larger teams let only a build machine upload. On a small team, a reset is easier: a new namespace prefix in the project settings starts a clean cache.
Onboarding stays simple. The cache settings live in the project settings, so they come with the repository. A new team member joins the VPN and opens the project.
Both approaches, cache server and content pipeline, might tackle the time cost you pay otherwise. But the content pipeline keeps the media out of the game project, and the cache speeds up whatever still has to be imported and built.
Build profiles and scripts
Fast builds also need to be the right builds. Switching between a development and a release build, or between Steam and GOG, often means changing settings by hand, which can leave the store with a debug build, the wrong store SDK or the wrong scene list.
- Build profiles. Since Unity 6, a build profile saves the platform, the scene list, scripting defines and player settings for one kind of build. Steam, GOG, development and release should each get their own profile, stored in the project.
- Pipeline scripts. A script builds each profile the same way every time, on any machine or on a build server. Nobody has to remember the steps. I use fastlane for this. It also covers the store uploads, which are just as slow and painful when done by hand every time.
When this does not fit
This strategy suits games whose content is structured and separable, like games with tons of data-driven levels or episodic content.
An action-adventure, or any game built around 3D level layouts, is different. There the content and the gameplay are tightly coupled, and levels cannot simply be moved out. This type of game would benefit more from a shared cache server.
This case study uses Unity and Addressables, although the principle carries over to other engines.
Questions for your own project
- How long does a clean build take for one platform?
- How long does a fresh import take, and how often does someone on the team need one?
- How many people touch your content and/or features?
- Which content in your project has not changed in the last month?
- Could that content be built once and downloaded instead?
- How many steps does your build and publishing process take, and how easily can you remember them?
If the answers add up to hours per week, the pipeline is worth a few days of attention.

