A media foundation independent of providers for software products

cRUD Research TeamThe cRUD Company

Whitepaper designed for the web

Software products that deliver live and recorded media depend on outside providers for real-time media, processing, storage and delivery. This white paper sets out how a media foundation can sit beneath such a product without letting provider behaviour or duplicated facts take over the product itself, using cRUD Morph as the reference.

Executive summary

  • When provider behaviour leaks into product logic, the product becomes harder to change and product facts end up duplicated in media systems.
  • cRUD Morph places behaviour tied to a particular provider behind ports and adapters and gives every fact exactly one owner.
  • Control, media, presentation state and customer interaction are separate planes, each with its own authority and failure boundary.
  • The paper closes with practical questions a product team can use to evaluate any media foundation.

Problem definition

When a product adds live or recorded media by starting from one provider’s software development kit, the first integration can be quick. The difficulty arrives later, when provider concepts start to shape the product itself. Provider identifiers sit beside product records, provider errors are handled in product code and provider limits become product rules.

Three problems follow. The product becomes coupled to one provider’s behaviour, so changing or combining providers means rewriting product logic. Product facts such as schedules, participants and roles are copied into media systems, so the two drift apart. And the product learns about outcomes from provider callbacks it does not control, so its view of what happened depends on someone else’s model.

None of this is a failure of any individual provider. What is missing is a foundation that governs media on the product’s behalf while keeping the product’s authority intact.

Architectural principles

cRUD Morph is built on six principles that work together.

Four planes, four failure boundaries

Control, media data, presentation and synchronised state, and customer interaction are separate planes. Each has its own authority and failure boundary, and they share only the minimum identities, correlation identifiers and timing contracts.

Providers behind ports and adapters

Behaviour tied to a particular provider stays behind provider ports and adapters. An adapter receives explicit policy and returns normalised receipts, capabilities, health and errors. It cannot decide customer entitlement or expose raw provider types through public contracts.

Outcomes from the contract

The customer product learns the outcome from a cRUD Morph contract event, not from the provider. Events leave only after the state change they describe is committed, and delivery is at least once with idempotent envelopes.

One owner for every fact

Every fact has exactly one authoritative owner, the customer product or cRUD Morph. Mappings connect the two without copying either side’s business entities.

Bytes take the direct path

The control plane issues policy and time-limited authority, but it does not carry bulk media. Eligible media flows through the selected media, processing, storage or delivery path.

A core shared by every customer

Core modules see capabilities in a common engine language, never one customer’s plan, role or product vocabulary. Behaviour unique to a customer stays in adapters.

The core itself chooses no media provider. Both cRUD Morph services use this boundary. BYOP, or bring your own provider, lets the customer own its provider account and pay the provider directly. With cRUD MIP, cRUD operates the approved provider capacity. The providers, regions and capabilities that serve a product are confirmed during the technical engagement, not assumed in the core.

Authority and responsibility boundaries

The boundary between the product and the media foundation is defined fact by fact. The customer product owns its business; cRUD Morph owns media execution and the evidence it produces.

Who owns each fact
FactAuthoritative ownerWhat the other side may hold
Customer organisation or workspaceCustomer productAn external reference mapped to an engine tenant
Webinar, event or meeting business identityCustomer productAn external reference mapped to engine resources
Users, profiles and business rolesCustomer productCapability grants and opaque participant references
Plans and entitlementsCustomer productTranslated capabilities only
Registration and admission decisionsCustomer productCommands limited to the capabilities created by those decisions
Chat, poll, Q&A and reaction contentCustomer productEnvelopes used only for transport or timing references, where needed
Media sessions, rooms and provider allocationscRUD MorphMorph resource identifiers mapped to customer references
Presentation state, when delegatedcRUD MorphAsset references and state events
Program Output identity and timelinecRUD MorphProgram Output references and events
Recording and media object lineagecRUD MorphObject references and signed access that expires
Usage facts produced by engine activitycRUD MorphCopies of the facts, which never become engine truth

Security boundaries follow the same pattern. Every engine resource belongs to one tenant and one environment. The server establishes tenant context, and authorisation is limited to approved capabilities and the minimum permissions required. Public identifiers do not grant access, secrets are represented by references, and access to media and state uses signed authority that expires.

Failure and degraded-state treatment

A foundation earns trust by how it behaves when something goes wrong. cRUD Morph treats partial failure as normal and does not let one plane’s problem rewrite another plane’s authority.

  • A media data plane failure does not change presentation state or Program Output authority.
  • A disconnection in synchronised state recovers from a snapshot plus ordered changes, and it does not infer authoritative state from media.
  • A customer interaction plane failure does not alter the state of a media session.
  • Gaps in provider receipts are reconciled, not overwritten by assumptions.
  • Partial failures do not silently mark work complete, and poison work reaches an explicit terminal state.
  • Rollback cannot create two simultaneous authorities.

For the people watching, the same honesty applies. Human video must never silently freeze to imitate a live stream. Quality degrades first, and if usable video cannot be maintained, the experience moves to an explicit audio or avatar state that is visible and truthful.

Evidence and measurement approach

cRUD Morph separates what is decided from what is observed. Policies are versioned decisions. Receipts, telemetry and usage facts are observations, recorded as evidence rather than assumed.

  • Provider receipts are normalised and deduplicated before they change state.
  • Delivery and quality telemetry belong to cRUD Morph, and usage facts are immutable.
  • Which codec a media path can carry is evidence, not policy. A choice is approved only when evidence supports every party on the path.
  • No saving in delivered data, percentage reduction or quality improvement is claimed without real measurement.

This approach is deliberately conservative. A foundation that reports unknown when it does not know is more useful to a product than one that reports success it cannot prove.

Practical evaluation questions

  1. Which facts does the media layer own, and which does it only reference? Ask for the ownership split in writing.
  2. Does any provider type, identifier or error appear in the public contract your product would use?
  3. Does your product learn about outcomes from the media layer’s contract or from provider callbacks?
  4. Are commands idempotent, and does each accepted command receive a stable request identity?
  5. Which states can an operation report, and is unknown one of them?
  6. What happens to presentation state and output authority if the media path fails?
  7. How are development, staging and Production separated, and can credentials cross between them?
  8. Which performance, quality or cost statements are backed by measurement, and which have not yet been tested?

Conclusion

A media foundation is valuable when it lets a product deliver media well without giving up authority over its own business. Boundaries independent of providers, one owner for every fact, separated planes and honest failure states are what make that possible. cRUD Morph is built around these principles, and the evaluation questions above apply to any media layer a product team is considering.

Basis and methodology

This paper sets out the public product principles of cRUD Morph and the architectural reasoning behind them. They include one owner for every fact, separate planes with separate failure boundaries, behaviour tied to a particular provider kept behind adapters and outcomes reported through the cRUD Morph contract. The same principles appear on the cRUD Morph approach page, and the provider models and shared responsibilities on the cRUD Morph documentation page.

The paper reports no external research, survey, benchmark or customer measurement. Its evaluation questions apply to any media foundation. Performance, quality and cost results for cRUD Morph are established for each engagement against a matched baseline, as the cRUD Morph overview explains.

About this white paper. It describes how cRUD Morph works. It makes no certification, performance, availability, savings or cost claim. Those results are measured for each engagement against a matched baseline.

Put your media architecture questions in writing.

Tell us what your product delivers and which media responsibility you want to evaluate.