Two decades of delivering software for top video streaming platforms have taught us that expandability, customizability, and scalability are critical parts of a software architecture and are vital for customer growth. Therefore, we designed Axinom Mosaic with these principles and focused on easy onboarding, code reuse, customization, and modularity. These principles ensure seamless integration and adaptability, allowing clients to rapidly tailor solutions to their needs.
Article
Enabling Customization
Strategies for Distribution of Software Components
In this article, we want to revisit and share the design considerations and key factors that shaped our current software strategy for Axinom Mosaic component distribution and customization.
In many cases, while designing software components, deliverability is overshadowed by the focus on system functionality and performance. However, ensuring that software can be maintained, distributed, and expanded is critical. Distribution models can be classified as follows:
-
API (SaaS) — Vendors host services on their premises and expose functionality through well-documented APIs. Customers don’t run anything themselves; instead, they call the vendor’s APIs, benefiting from the vendor’s management and scalability.
-
Binary — Vendors provide precompiled, executable components that customers can run in their environments. This method allows customers to deploy software quickly without worrying about compiling or modifying code.
-
Source Code — Vendors ship the source code, allowing customers to compile and customize the components. This approach provides more flexibility but requires technical expertise and effort from the customers.
Let’s examine the benefits and challenges of the source code distribution model compared to others employed in large-scale infrastructure.
Navigating Binary and API Distribution
In most actual use cases, customers require some customization for the components before adopting them. There are various techniques for how customization can be achieved, for example:
-
Configuration: Vendors define multiple options that customers can choose from, typically using configuration files.
-
Plugins and Extensions: Components have defined extension points where customers can plug in their implementations as plugins or extensions, enhancing functionality at runtime.
-
Webhooks: Similar to plugins, webhooks are invoked via HTTPS, allowing for real-time integration with external systems.
-
UI Customization: Customers can modify the look and feel of components through theme settings, custom CSS, or templates.
Software vendors sometimes even go as far as to create Domain-Specific Languages (DSLs) to facilitate customization, offering great possibilities. But it also introduces complexities such as requiring users to learn a new language and introduces another abstraction level.
These techniques enable customization without altering the source code, but they have vendor-defined limitations. Binary and API distribution usually works best if a component encapsulates extensive business logic while the customization options are sparingly used.
However, extensive customizations can get difficult:
-
Configuration Management: Keeping track of modified options and their impacts can become complex.
-
Testing: Testing all possible customization combinations is crucial before deploying to production.
-
Release and Deployment: Consistently applying customizations across environments can be challenging.
-
Troubleshooting: Complexities in identifying issues and debugging customized components.
-
Documentation: As customizations increase, maintaining accurate documentation becomes critical for knowledge transfer within the organization.
-
Updateability: Upgrading components can be complex if customizations are extensive, as new versions may break existing modifications.
-
Extensibility points: The vendor defines the scope of the customizability and hence limits the options.
Source Code Distribution
Traditional customization methods often assume that modifying the original software is complex, offering ways to add functionality without altering the source code. However, with modern software development tools and techniques, modifying source code has become significantly simpler, faster, safer, and more reliable. IDEs, source control management tools, code generators, and practices like unit testing, DevOps, and continuous delivery all contribute to making source code changes a predictable and even enjoyable experience.
The key prerequisite is that components must be delivered as source code. Once you have access to the source code, you can leverage the technological advancements of recent decades without needing to reinvent the wheel by creating custom DSLs, editors, designers, validators, and other tools.
Modern software development tools make customization guesswork unnecessary, making software design more flexible and extensible. Developers can use their usual tools for development, troubleshooting, and deployment instead of using new languages and techniques.
Source code customization requires navigating certain obstacles:
-
Entry Barrier: The learning curve might be steep for minor customizations, making other techniques more appealing.
-
Technology Fit: Source code customization only makes sense if the customer’s developers are fluent in the vendor’s technology stack.
-
Updateability: Applying vendor updates to customized code can be challenging, especially for significant changes. Small changes can usually be applied well using source control tools like Git, but more substantial changes are impractical when merging.
The Axinom Mosaic Way
Axinom Mosaic is a modular, service-oriented platform that provides the necessary tools and services to build customized backend solutions for media management. With the Mosaic approach, we address customers with in-house development teams who want to combine best-of-breed components, existing third-party services, and their in-house customizations and components.
Drawing on over a decade of experience with video backends and the insights gained from building large-scale architectures, we have opted for a hybrid approach that includes the following key components:
-
Managed Services (SaaS, API Distribution) for functionalities requiring minimal customization, such as DRM Service, Encoding Service, and Localization Service, Axinom offers managed services that leverage API reuse.
-
Customizable Services (Source code Distribution), where open-source templates are provided for components with higher customization needs, like Media Service and Catalog Service, allowing for source code reuse and maximum flexibility
-
Libraries (Binary Distribution) - where ready-to-use libraries simplify backend and frontend development by handling everyday tasks such as messaging, logging, authentication, and UI controls. These libraries are available in binary and source code form for easy debugging.
By offering this modular and service-oriented platform, Axinom empowers customers to quickly leverage standard functionality while allowing them to reuse source code as much as needed. Our research on the decision-making process between building or buying in video streaming strongly supports this approach. Respondents favored decoupling services, with nearly 80% of OTT, VOD, and streaming providers indicating they customized their products before deployment—split evenly between in-house development and vendor solutions.
Open Source: Empowering the Community
While delivering source code offers the highest level of customization, an important question arises: how should the code be licensed? Axinom’s approach to licensing its reusable components (customizable services and libraries) under a widely used and very permissive open-source MIT license, brings several benefits to the community:
-
Transparency: The source code and licensing conditions are open, ensuring compliance with standards and avoiding legal entanglements.
-
Cost Savings: Using and developing based on the provided templates is free, as Axinom’s revenue comes from managed and core services.
-
Community Support: Customers can contribute to the development of the templates, helping shape the platform’s direction.
-
Security: Public visibility of the code allows vulnerabilities to be identified and patched quickly.
-
Vendor Independence: Customers can freely involve any third party in development or customization, avoiding vendor lock-in.
-
Familiar Delivery Channels: Mosaic components are delivered via GitHub (source code) and NPM (binaries), popular tools among developers.
A Flexible Future
Ultimately, with Axinom Mosaic, we offer a compelling narrative of flexibility and empowerment in the software development landscape. By combining binary, API, and source code in the form of managed services, open-source templates, libraries, and clear extensibility points, customers can create custom solutions without needing to learn new frameworks or languages.
