If you've spent more than a year inside a game or VFX studio, you've heard the word "pipeline" hundreds of times. It's one of those terms that everyone uses but very few people define precisely. In my experience building character pipelines for the Mortal Shell franchise, I've come to think of a pipeline not as a single thing, but as a living system of connected decisions that govern how data moves from an artist's imagination to a player's screen.
Let me walk you through how a modern production pipeline is actually structured — not the textbook definition, but the real anatomy I've seen working across both game and animation studios.
What Is a Pipeline, Really?
The simplest definition I use: a pipeline is the set of rules, tools, and automation that moves data through a production. It's the invisible nervous system connecting concept artists to riggers, riggers to animators, animators to engine integration, and everything to the final build.
But unlike a physical pipe, a production pipeline is rarely linear. It's more of a directed graph — data flows in multiple directions, loops back for revisions, branches for platform-specific builds, and occasionally needs to be rerouted entirely when a creative decision changes upstream.
Data doesn't flow in one direction — revision loops are a fundamental part of every pipeline.
The Three Production Phases
Every production — whether you're building an indie game or a AAA franchise — passes through three macro phases. Understanding these phases isn't just project management theory; it directly shapes what your pipeline needs to do and when.
1. Pre-Production
This is the phase where directions are explored but nothing is locked. From a pipeline perspective, the critical work here is establishing standards: naming conventions, directory structures, file-exchange formats, and the skeleton of your asset-tracking system.
Every shortcut you take in pre-production will haunt you during production. I've seen studios lose entire weeks because their file-naming conventions broke down when they hit 200+ assets. Define your conventions early, and enforce them through automation, not discipline.
Pro Tip
Never rely on artists to follow naming conventions manually. Build validation into every save and publish action. If a file name breaks the pattern, the tool should reject it with a clear error — not silently accept it.
2. Production
Production is where the pipeline is tested under real load. This is when you discover that your elegant directory structure doesn't scale, your version control policy creates merge conflicts daily, or your render farm can't handle the sheer volume of assets.
The key insight I've learned: the pipeline should never be "finished" before production starts. A good pipeline team ships the 80% solution and iterates it under live fire, maintaining close communication with supervising artists.
Productions ramp up, peak, and taper — your pipeline infrastructure must be elastic enough to handle this curve.
3. Finalling / Post-Production
This is the most dangerous phase for a pipeline. The pressure is at maximum, artists are making rapid-fire changes, and any instability in your toolchain becomes catastrophic. In games, this is called "gold mastering." In film, it's "finalling."
Your pipeline's job during finalling is simple: don't break anything. Lock your tools, freeze your infrastructure upgrades, and make sure every change is tracked, reversible, and approved by supervisors before propagating downstream.
The Invisible Infrastructure
Behind every artist-facing tool, there's an invisible layer of infrastructure that makes the pipeline actually work. This includes:
- Directory structures — how files are organized on disk. The perennial debate is flat vs. deep: flat structures are easy to navigate but collapse under scale; deep structures scale well but can become impenetrable forests of nested folders.
- File-naming conventions — a consistent syntax that encodes metadata directly into the filename (project, asset type, variant, version number). This sounds trivial, but I've seen it save studios when database queries fail and people need to find files manually.
- Version control — game teams live and die by Perforce; film teams tend to use custom solutions built around database-tracked revisions. The key decision is whether file access is exclusive (one person at a time) or non-exclusive (merging required).
- Metadata — the invisible data attached to every file: who created it, when, what it depends on, and what its current approval status is. Without metadata, you don't have a pipeline — you have a folder with files in it.
A well-designed directory structure mirrors the logical dependencies of your production — data flows from work areas to publish.
Film vs. Game: Two Philosophies
Having worked across both animation studios and game teams, the biggest difference I've experienced isn't technical — it's philosophical.
In film, data flows in one direction toward a predetermined endpoint: the final rendered frame. Every asset has a known destination. The pipeline's job is to shepherd data reliably down a relatively predictable path.
In games, data must be interactive and runtime-efficient. The "final frame" is generated millions of times per second on unknown hardware. This fundamentally changes every optimization decision: LODs (Levels of Detail) become mandatory, texture budgets are enforced ruthlessly, and every asset must be validated against real-time performance targets before it can ship.
The Convergence
Interestingly, these two worlds are converging. Virtual production in film now uses real-time engines like Unreal Engine for on-set visualization, while AAA games increasingly adopt film-quality rendering techniques (ray tracing, Nanite, Lumen). This means modern Pipeline TDs need to understand both paradigms.
Why Every Studio Rebuilds
Here's the uncomfortable truth: pipelines are never truly finished. They evolve with every project because the requirements change. New DCC software, new engine versions, new hiring patterns, new client demands — all of these force the pipeline to adapt.
The best pipeline teams I've worked with don't build monolithic systems. They build modular micro-pipelines: small, self-contained units of automation that can be swapped, upgraded, or replaced independently. A rigging micro-pipeline handles the journey from model to rig to animation-ready asset. A publishing micro-pipeline handles validation, versioning, and deployment. Each one has clean interfaces — inputs they expect, outputs they guarantee.
This modular approach is what separates a pipeline that survives two projects from one that needs to be rebuilt from scratch every time.
The Human Factor
The most technically elegant pipeline fails if artists refuse to use it. I've learned this the hard way. You can build the most sophisticated dependency tracker in the world, but if it adds three extra clicks to an artist's daily workflow, they'll find a workaround.
This is why the best pipeline work is invisible. The validation happens behind save actions. The versioning is automatic. The metadata is extracted, not entered. The artist should feel like they're just doing their creative work — the pipeline does the rest.
The measure of a good pipeline isn't how much it can do — it's how little the artist has to think about it.
Key Takeaways
- A pipeline is a living system, not a one-time build. Design for change from day one.
- Enforce standards through automation, not documentation. If a rule can be broken, it will be.
- Build modular micro-pipelines with clean interfaces. Monolithic systems are fragile.
- Optimize for the artist's workflow, not the engineer's elegance. The best pipeline is invisible.
- Plan for the production curve. Your infrastructure must scale up during production and withstand the chaos of finalling.