Media pipeline
In-house encoding
Masters are transcoded into a multi-bitrate adaptive ladder, segmented, and published to origin storage — a pipeline we own rather than a vendor we bill through.
Streaming & cloud infrastructure
We didn't assemblea streaming platform.We engineered one.
A complete OTT platform, a private cloud, and a content delivery network — all built in-house and all running on our own bare metal. No per-gigabyte egress bill. No per-minute transcoding vendor. No per-session analytics licence. The whole stack is ours, which is why it costs a fraction of the rented equivalent.
Own the metal
Bare-metal, on-premises
Own the pipeline
Encode · deliver · measure
Own the code
21 codebases, 4 languages
Own the numbers
100% infrastructure as code
290
REST endpoints
across 14 services
21
Codebases
independently deployable
18
Isolated guests
on a single 2U node
22
Terraform modules
the whole estate, in code
What we build
Three layers, one team
Most streaming companies buy two of these and build one. We build all three, which is why they fit together instead of merely connecting.
01
OTT platform
A complete subscription video service: catalogue, search, recommendations, billing, entitlements, pay-per-view, live channels and native apps for web, phone and television.
- Adaptive HLS with AES-128 encryption
- Subscription, pay-per-view and coupon billing
- Concurrent-device limits enforced at play time
- One native binary for phone and Android TV
02
Private cloud, on premises
A virtualised estate on hardware we own and physically hold: isolated compute, GPU passthrough, S3-compatible object storage, and a full observability stack — declared entirely in code.
- Bare-metal hypervisor, no rented instances
- GPU-accelerated transcoding on the same node
- S3-compatible object storage for origin
- Metrics, logs and dashboards built in
03
Delivery network
Our own edge, compiled from source for the job: range-aware caching so a mid-film seek is served from disk, geographic awareness, HTTP/3, and a token check on every single segment.
- Slice-based range caching
- HTTP/2 and HTTP/3 termination
- Per-segment authorisation, not per-session
- Cache invalidation on demand
The platform
Built for the moment playback starts
Every streaming product is judged in the first two seconds. Playboox is engineered around that window — and around the thousand seconds that follow it.
Video is prepared once and prepared properly: a single master becomes an adaptive ladder that steps cleanly between quality levels as a connection moves, so the picture degrades gracefully instead of stopping. Delivery runs on our own edge, with range-aware caching that serves a mid-film seek from disk rather than reaching back to origin.
Playback is instrumented the way a broadcaster instruments it. Every session reports start-up time, rebuffering, bitrate changes and errors back into a purpose-built analytics store, so quality is a number we watch rather than a complaint we wait for.
The apps are native where it counts. One codebase produces the phone and the television experience, sharing playback, entitlement and design so both move forward together.
Fast
Cached at the edge, close to the viewer. Manifests and keys are served in milliseconds so the first frame is not waiting on a round trip.
Smooth
An adaptive ladder tuned per title. Quality steps down before a buffer empties, not after — the stream bends rather than breaks.
Measured
Start-up time, rebuffer ratio and error rate land in analytics per session. Playback quality is monitored continuously, not sampled.
Network
One frame, end to end
Two paths in, one protected path out. This is the route every second of video takes — from a camera or a master file, through our own encoding and our own delivery network, to a screen. Nothing in the chain is rented.
01
Live
A broadcast feed arrives over standard contribution protocols, is handed off with minimal delay and repackaged into encrypted segments as it runs.
02
On demand
A master file is transcoded once into a full quality ladder, encrypted, and published to origin storage ready to be served forever after.
03
The return path
Every player reports what it actually experienced — start-up time, rebuffering, errors. That data comes back to us continuously and informs how the ladder is tuned.
Infrastructure
A cloud we can walk up to
The entire platform runs on hardware we own and physically hold. Not a rented region, not a shared tenancy — a hypervisor on our own rack, carved into isolated machines and declared, every line of it, in version control.
Each service gets its own virtual machine or container: its own kernel, its own network address, its own failure domain. A misbehaving encoder cannot reach the billing database, and a rewrite of one service never means redeploying another.
Transcoding runs GPU-accelerated on the same node, so a master file never leaves the building to be encoded. Origin storage is S3-compatible, which means the day it makes sense to move it to a public cloud, the services reading from it do not change a line.
- Hypervisor
- Bare-metal, self-hostedno rented instances anywhere in the path
- Compute
- 96 vCPU · 156 GB RAMa single 2U node runs the whole estate
- Isolation
- 18 separate guestsone service, one failure domain
- Acceleration
- GPU passthroughhardware transcoding on the same box
- Storage
- S3-compatible originportable to any object store
- Declared in
- 22 Terraform modules≈5,600 lines, all in version control
Three ways it can run
On our metal
The platform as it runs today — our hardware, our network, our operational responsibility. Lowest cost per stream and nothing to negotiate with a vendor.
On yours, on premises
The same stack, declared in the same Terraform, stood up inside your own datacentre. Useful where content, data residency or regulation cannot leave the building.
Lifted to public cloud
Nothing in the stack is tied to our hypervisor. Object storage is S3-compatible and every service is containerised, so a migration is a change of target, not a rewrite.
Developer surface
Everything is an API
The platform is not a monolith with a web page bolted on. Every capability — catalogue, playback authorisation, billing, live channels, search, telemetry — is a documented REST endpoint that our own apps consume exactly the way an integrator would.
290
Total endpoints
48
Public surface
242
Private surface
gRPC
Streaming progress
Catalogue
37 endpoints- GET
/titlesPaginated catalogue
- GET
/titles/:idTitle detail
- GET
/titles/:id/episodesEpisode list for a series
- GET
/titles/searchSearch by title
Playback
46 endpoints- GET
/api/v1/homeThe whole home screen in one call
- GET
/api/v1/vod/:id/authorizeEntitlement check, then a signed playback URL
- GET
/api/v1/live/:slug/authorizeEntitlement check for a live channel
- GET
/api/v1/vod/:id/nextUp next
Billing
18 endpoints- GET
/plansAvailable subscription plans
- POST
/subscribeCreate a subscription
- POST
/purchaseBuy a single title or a pay-per-view event
- GET
/entitlement/:userIdWhat a viewer may watch right now
Live & encoding
31 endpoints- GET
/channelsLive channel list
- POST
/jobsQueue an encode
- GET
/jobs/:idEncoding job status
- GET
/issue-token/:folderMint a signed playback token
290 endpoints across 14 services. Of those, 48 are reachable from the public internet; the remaining 242 sit on a private network with no route in from outside. That ratio is a design decision, not an accident.
Economics
The cheapest gigabyte is the one you don't rent
A streaming service of this shape normally pays three vendors that all bill by usage: one to transcode, one to deliver, one to measure. Every additional viewer increases all three. We removed all three.
The rented model
- Per-minute transcoding, billed per rendition
- Per-gigabyte egress, billed on every segment
- Per-session analytics licensing
- Per-instance compute, priced by the hour
- Costs scale up with every new viewer
Ours
- Transcoding on a GPU we already own
- Delivery from an edge we compiled ourselves
- Analytics into a store we operate
- Compute on metal already paid for
- Marginal cost of a viewer approaches bandwidth alone
This is not a discount. It is a different cost structure. Owning the pipeline converts a variable cost that grows with success into a fixed cost that does not — which is precisely the curve a subscription business needs.
Engineering
The stack, end to end
Independently deployable services, each responsible for one thing, each able to scale or move without disturbing the rest. Below is what actually runs.
Delivery
Our own CDN edge
A purpose-compiled edge with slice-based range caching, geographic awareness and HTTP/3. A seek into the middle of a film is served from cache, not fetched again from origin.
Content protection
Token-gated AES delivery
Every stream is encrypted. The decryption key is released only against a signed, expiring token, and the edge re-verifies that token on every segment — continuously, not once at the start.
Performance
Redis caching layer
Hot catalogue reads and session state are held in memory at the application tier, so the pages a viewer hits most never touch the database twice.
Observability
Playback QoE analytics
Player telemetry streams into a column store built for continuous ingest, turning start-up time, rebuffering and error rates into dashboards we act on.
Backend
Microservice architecture
Catalogue, billing, live, search, recommendations and encoding run as separate services. One failure is contained; one rewrite is scoped.
Clients
One binary, phone and TV
A single native application installs on handsets and on television, sharing playback, entitlement and design system so both surfaces ship together.
Operations
Infrastructure as code
Every server, service and network path is declared in version control. The platform is reproducible from its written definition — not from anyone's memory.
Discovery
Search and recommendations
A dedicated search index and a recommendation service that rebuilds on a schedule, so discovery is a first-class service rather than a database query with a LIKE in it.
How we work
Operated like production, because it is
The difference between a demo and a platform is what happens on the days nobody is watching. These are the habits that make the second one possible.
01
Everything in version control
Servers, services, network routes and firewall policy are all declared as code. Rebuilding the estate is a command, not an archaeology project.
02
Measured, not assumed
Metrics, logs and playback telemetry all land in one observability stack. Capacity, error rates and playback quality are numbers on a dashboard, not opinions.
03
Backed up and restore-tested
Guest-level backups run nightly with retention. A restore has been performed and verified end to end — an untested backup is a belief, not a backup.
04
Reviewed before it ships
Infrastructure changes are planned, read and approved before they touch a running guest. Nothing reaches the hypervisor because a script felt confident.
05
Least privilege by default
Service-to-service calls carry scoped credentials, mutating endpoints are gated, and the public surface is deliberately a small fraction of the total.
06
Documented as we go
Every procedure, decision and rollback path is written down at the time it happens — including the mistakes, because those are the ones worth not repeating.
Questions
The things people actually ask
Is this a product I can buy, or a platform you operate?
Today it is a platform we build and operate, running a live consumer service. The same stack is declared in code and can be stood up on other hardware — ours, yours, or a public cloud — which is what makes it a foundation rather than a one-off.
Why build a CDN instead of buying one?
Because delivery is the largest recurring cost in streaming and the one with the least differentiation available for money. Compiling our own edge gave us range-aware caching tuned to how people actually watch, per-segment authorisation, and a bill that does not grow with every gigabyte.
How is the content protected?
Every stream, live and on demand, is encrypted. The decryption key is released only against a signed, expiring token, and the edge re-checks that token on every segment rather than once at the start of playback. Copying a link does not copy access.
What happens when you outgrow one server?
The estate is declared in Terraform and every service is containerised behind its own address, so adding a node is adding capacity, not re-architecting. Object storage is already S3-compatible for exactly this reason.
How do you know playback is actually good?
Because every session tells us. Start-up time, rebuffer ratio, bitrate changes and errors stream back from every web and mobile player into an analytics store built for continuous ingest. Quality is monitored, not surveyed.
How much of this was built in-house?
The encoder, the delivery edge, the token system, the analytics pipeline, the APIs, the web app and the native apps. Twenty-one codebases across four languages. The parts we did not write are the well-understood building blocks underneath — databases, a message broker, a search index.
Let's talk about what you're building
Whether that is a streaming service, a private cloud, or delivery infrastructure that has become too expensive to keep renting — the fastest way to start is a conversation.