The ability to personalize viewing experiences at a granular level is one area in which online video separates itself from traditional TV. Consumer expectations are rising, be it for the quality and value of the service or the relevance of the ads they’re seeing. Meanwhile, content providers need to manage regional rights restrictions, secure the content and also monetize it with appropriate ads.
As we all know, content providers don’t always apply the most optimal methods and tools to best meet these expectations and requirements. Efforts to personalize content today are often inefficient, struggle to scale, add unnecessary rigidness and costs into video workflows and storage while limiting what can be personalized at an individual level.
Alternatively, many content providers are using manifest manipulation to personalize the video experience for each viewer. When a stream is requested, video and audio segments are accompanied by a manifest file that acts as a playlist and determines the playback order. The ability to change or customize the manifest dynamically, at a per user level, opens up numerous opportunities to tailor the viewing experience. In the case of live video, a new manifest is delivered with each segment of video requested, allowing adjustments to be applied dynamically as viewing conditions change. Executing this function at the edge, allows content providers to offload complexity from early on in the content preparation process and dynamically apply advanced logic for an individual viewer just prior to delivery. Meanwhile, enhancing scale to reach larger audiences.
Examples of functions that can be handled by manifest manipulation include:
- Monetization: CDNs can work in tandem with ad decision systems to enable dynamic ad insertion on a per-user basis.
- Personalized Streaming: Optimize video playback quality (bitrate selection) based on user, device type, network conditions or geography
- Content Security: Protect content against unauthorized viewing using scalable session-level encryption, access control and watermarking
- Content Localization: Apply regional variations including audio tracks, closed captioning and subtitles
- DVR and Clip Creation: Dynamically create highlight clips, DVR windows and time shifting
- Content Rights Compliance: Program Replacement – Adhere to content rights restrictions by replacing content in restricted regions
When it comes to content providers personalizing content for their viewers, there are three main challenges they face.
Challenge 1: The One-Size-Fits-All Approach to Content Preparation
Delivering personalized content to fragmented audiences is difficult and costly when preparing video in a cookie-cutter fashion. This often entails creating large sets of manifest files with similar bitrate ladders across a wide range of supported formats, codecs and ad copy with additional localized variants. This approach not only places unnecessary complexity on the content creation phase, it adds cost by expanding the content library storage footprint.
When delivering the content to an end-user, this approach can fail to deliver a truly authentic, personalized experience as it’s not actually targeted at an individual. The amount of permutations created in the content preparation phase are finite, the content is precast to the end-user and rarely appears relevant from the perspective of the viewer.
Challenge 2: Customizing Manifests at Origin
Content providers that host and originate their content in the cloud sometimes attempt to process manifests at origin. Doing so can be extremely compute intensive and cause cloud costs to rise quickly. Creating personalized manifest files at origin is also inefficient as the static manifest is first created, then passed to a CDN for delivery, but can’t be cached efficiently by the network. When a content provider is delivering live or on demand content to large audiences, the compute-heavy method is intensified by the additional strain it places on the origin from additional end-user requests, which ultimately drives additional cost. This method can add undue latency and impact delivery performance.
Challenge 3: Reliance on Clients
Those that rely heavily on their client implementation to personalize viewing are limited to the capabilities of their client stack which are often inconsistent across platforms. Even though many clients can support a range of the desired personalization capabilities such as localization, targeted ads and more, scale can be an issue. Client side dynamic ad insertion implementations can struggle to handle programmatic decisioning quickly and at scale. Content security measures are often reliant upon the server-side logic to enforce policies. Meanwhile, managing implementations across the landscape of supported devices that require frequent updating creates a fragmented environment that’s hard to maintain. Depending on the end-user client also places additional burden upon a technology stack that is often heavy and reliant on third parties. Choosing a client strategy to handle personalization functions pushes added complexity onto an already brittle environment where errors can significantly impact playback.
Because of these challenges, many content owners are realizing the advantages of handling manifest manipulation at the network edge. Utilizing manifest manipulation at the edge of the internet enables personalization at greater scale that can be achieved using a client side approach. Using a widely distributed network can reach large audiences with customized manifests across the landscape of devices and browsers without concerns around player updates and heavy reliance on third-party software. For a diagram on how this work, check out a blog post Akamai did on this topic here.
It can also be less costly than creating manifests at origin. Executing at a per session level provides more flexibility than the one size fits all approach by handling requests dynamically at the edge as opposed to placing undue complexity and rigidity earlier in the in content preparation phase. In addition, manifest manipulation offers a graceful way to handle certain issues that happen upstream, for example within the ad decisioning workflow. In a client side approach, an error where the ad copy isn’t delivered in time could result in a blank screen, whereas a server-side implementation could replace the absent ad with other content to avoid the impact on the user experience.
Handling manifest manipulation at the edge offers many advantages around scale, flexibility and intelligence and seems to be the route content owners are moving towards industry wide. I’d love to hear from others in the comment section on how you are addressing this problem, or helping clients address it.
