Every Pipeline TD will eventually face a moment of reckoning: the team needs a tool, the shelf doesn't have exactly what's required, and the PM is asking for an ETA. In that pressure-cooker decision, three paths diverge — build it from scratch, buy a commercial license, or tinker with something open-source.
None of these is universally correct. The right answer depends on project timeline, team size, maintenance budget, and strategic IP considerations. What follows is a framework, distilled from years in the trenches of both film VFX and game development pipelines.
The Decision Framework
Before reaching for any keyboard or purchase order, answer these four questions:
- Is this a core competency? If the tool relates directly to your studio's primary value proposition (e.g., a proprietary rigging solver), build it.
- Does the problem already have a robust commercial solution? Licensing Shotgun/ShotGrid for production tracking is almost always cheaper than building an equivalent system.
- How critical is longevity and maintenance? Open-source tools require an internal champion. If nobody owns it, it rots.
- What is the integration surface area? A tool that needs to speak to Maya, Unreal, Perforce, and your custom asset tracker simultaneously has a complex integration surface — that complexity may justify building.
"The cheapest tool is the one you don't have to maintain. But the most valuable tool is the one your team will actually use."
When to Build
Building in-house is the right answer when your requirements are genuinely unique. Character rigging solvers, custom export pipelines for proprietary game engines, or procedural asset generation systems often fall into this category. The advantage of bespoke tools is tight integration and full control over the roadmap.
The critical discipline here is development policy. Without a formal release cycle, testing suite, and documentation standard, in-house tools accumulate technical debt at an alarming rate and become un-maintainable within two production cycles. A pipeline that runs on undocumented black-box scripts is one key employee departure away from catastrophe.
In-House Development Checklist
- Dedicated R&D owner with a clear scope document
- Unit tests (pytest, or DCCs like Maya's own testing framework)
- Changelog and versioned releases (even internal tools deserve SemVer)
- User-facing documentation (at minimum, docstrings and a README)
- Error reporting mechanism so users can log failures without filing a ticket with a human
When to Buy
Commercial software shines when the problem is well-defined, industry-standard, and vendor-maintained. Production management (ShotGrid/Jira), render management (Deadline, Tractor), and asset review (Shotgun Review, Frame.io) are all categories where buying is almost always cheaper than building when you factor in full operational cost.
| Category | Commercial Solution | Build If... |
|---|---|---|
| Production Tracking | ShotGrid / Jira | Your workflow is extremely non-standard |
| Render Management | AWS Deadline / Tractor | Your render jobs have unique graph dependencies |
| Asset Review | Frame.io / DJV | You need in-DCC review with custom metadata |
| Rigging / Solvers | Faceware / Advanced Skeleton | You need IP control or proprietary deformer tech |
When to Tinker
Open-source software often sits in a sweet spot — it covers 80% of what you need, and the remaining 20% can be added by extending the codebase. Tools like ASWF standards (OpenEXR, OpenColorIO, USD) are the bedrock of modern VFX pipelines. They are free, industrial-strength, and actively maintained by a broad community.
The risk is implicit ownership. When you fork open-source software and extend it, you now own a custom fork. Upstream changes become painful to merge, and if your internal champion leaves, the fork often dies. The discipline here is to push changes upstream whenever possible — contributing back to the project keeps your delta small and keeps you aligned with the community roadmap.
Hybrid Architectures
The most resilient pipeline architectures I have worked with employ all three strategies simultaneously. Commercial tools handle production management and render wrangling. Open-source standards (USD, OpenColorIO) glue the data layers together. And bespoke in-house tools handle the genuinely unique creative and technical requirements specific to the studio's IP.
The integration layer between these three tiers is often the most critical engineering challenge — and the most rewarding to solve.