The Challenge: Scaling Camera File Processing Across Hundreds of Productions
Netflix ingests hundreds of hours of camera-original footage daily, spanning dozens of camera formats, codecs, and metadata schemas. Each production—from a small indie film to a blockbuster series—brings unique creative and technical requirements. The traditional approach of manual file wrangling and bespoke per-production pipelines simply doesn't scale.
Instead of building every component in-house, Netflix's Media Production Suite (MPS) team chose to integrate with trusted industry partners. This article (based on Netflix Tech Blog's original post) explains how they partnered with FilmLight to use their FLAPI as the core media processing engine—running entirely in Netflix's cloud compute infrastructure.
Why Not Build an In-House Image Processing Engine?
Building a world-class image processing engine from scratch would require:
- Deep, continuous collaboration with camera manufacturers
- Maintaining color science expertise across dozens of formats
- Keeping pace with new codecs and open standards (ACES, ASC MHL, FDL)
Netflix's philosophy: partner where deep domain expertise already exists. FilmLight's Baselight and Daylight are battle-tested in the industry for color grading, dailies, and transcoding. By integrating FLAPI as a backend API, MPS gained:
- Consistent metadata parsing across any camera format
- Trusted color science (debayering, ACES, AMF)
- Rapid support for new cameras without internal R&D
Architecture: Cloud-Native, Serverless, Elastic
MPS is not a single application—it's an ecosystem of services. The key architectural decisions:
1. Containerized FLAPI in Docker
FLAPI is packaged as a Linux Docker image, making it deployable identically in both cloud and on-premise compute centers. This ensures consistent footage assessment regardless of location.
2. Cosmos Stratum Functions (Serverless)
Netflix's Cosmos compute platform provides serverless functions that accept:
- Input clip and output location
- Frame ranges (for partial renders)
- AMF or FDL files (for color and framing decisions)
# Example: Invoking a Cosmos Stratum Function for VFX plate generation
import boto3 # AWS SDK (Netflix uses internal equivalent)
client = boto3.client('lambda')
payload = {
"input_clip": "s3://production-footage/episode1/scene5.A001_C001_0123KZ.RDC",
"output_location": "s3://vfx-plates/episode1/",
"frame_range": {"start": 100, "end": 250},
"amf_path": "s3://color-pipeline/episode1_amf.xml",
"fdl_path": "s3://framing-decisions/episode1_fdl.json"
}
response = client.invoke(
FunctionName='mps-vfx-render',
InvocationType='Event', # async
Payload=json.dumps(payload)
)
print(f"Render job submitted: {response['StatusCode']}")
3. CPU-Only Instances for Cost Efficiency
FLAPI supports GPU rendering, but Netflix deliberately runs on CPU-only instances. This gives access to a much wider compute pool and frees GPUs for other workloads. The trade-off is acceptable because parallel encoding (many small jobs) beats single-instance power for their spiky production workloads.
Key Workflows Powered by FLAPI
Inspection & Metadata Extraction
When footage is ingested, MPS uses FLAPI to:
- Parse camera metadata (reel name, timecode, lens, ISO, white balance)
- Normalize to Netflix's schema
- Make metadata searchable for downstream matching and debugging
VFX Plate Generation
Visual effects workflows demand:
- Accurate framing (via ASC FDL files)
- Consistent color management (via ACES Metadata Files)
- Correct debayering/decoding parameters
FLAPI handles the heavy lifting, and MPS automates the orchestration. The result: VFX plates are generated with the same color science as dailies, eliminating mismatch headaches.
Elastic Scaling for Spiky Workloads
Production workloads are inherently unpredictable:
- A quiet day: minimal new footage
- A VFX turnover: thousands of parallel renders needed in hours
By deploying FLAPI as serverless functions, MPS can:
- Allocate compute on demand
- Release resources when queues drain
- Swarm pull requests to meet tight deadlines
This elasticity avoids the pain of managing fixed render queues. Filmmakers get lightning-fast turnaround without manual prioritization.
Collaboration & Open Standards
The partnership with FilmLight goes beyond API integration. Netflix and FilmLight collaborate on:
- Feature roadmaps (new camera formats, open standards)
- Validation of accuracy and performance
- Debugging edge cases at scale
A concrete example: ACES 2 support. FilmLight quickly provided a roadmap; Netflix's engineers provided feedback to ACES technical leadership. This positive feedback loop benefits the entire industry.
Limitations & Considerations
- Vendor dependency: Relying on FLAPI means Netflix's processing speed and format support are tied to FilmLight's release cycle. However, the partnership model reduces Netflix's own maintenance burden.
- Cloud cost management: While CPU-only instances are cheaper per unit, the sheer volume of transcoding jobs (especially during VFX turnovers) can still incur significant cloud costs. Netflix mitigates this with elastic scaling and cost monitoring.
- Not a silver bullet: FLAPI excels at camera-original processing, but MPS still needs complementary tools for audio, subtitles, and non-camera media.
Next Steps & Learning Path
- For engineers building similar systems: Start with a small proof-of-concept using Docker and a serverless framework (e.g., AWS Lambda, Google Cloud Functions). Integrate with a media processing library (like FFmpeg or a vendor API) to validate the architecture.
- For production teams: Understand the cost/performance trade-offs of CPU vs. GPU. Netflix's approach favors parallelism; your mileage may vary depending on job types.
- Stay updated on open standards: Follow ACES, ASC MHL, and FDL developments. They are becoming the backbone of interoperable media workflows.
Conclusion
Netflix's MPS shows that smart integration beats custom building when you have trusted partners and a clear architectural philosophy. By treating image processing as a specialized discipline and embracing serverless, elastic compute, Netflix delivers smarter, more reliable workflows to productions worldwide.
The result? Fewer delays, faster VFX plate turnaround, and—most importantly—more time for filmmakers to focus on storytelling.
Related Reading
- Building a Scalable AI Diagnostics Platform: How Artera Leveraged AWS for Prostate Cancer Care
- Beyond Static Suites: How Just-in-Time Testing is Revolutionizing QA for the Agentic Era
