The legacy deal in tech? Build it once, build it huge, and hope it can handle everything the digital world throws its way – impressive, maybe, but incredibly hard to change or move. This monolithic approach, while familiar, often struggles to keep pace with the fluid nature of digital transformation, becoming a bottleneck that stifles innovation and delays crucial market entry.
Understanding Microservices Architecture: The Agile Evolution
Think about those moments your typical digital platform truly gets tested. The Black Friday checkout frenzy. The song that suddenly owns everyone’s playlist on Spotify. The Netflix series that sparks a global binge. These aren’t just traffic spikes; they’re the moments that reveal your underlying potential. Can your architecture handle the pressure with grace?
The old answer – the monolith – often defaults to brute force: over-provisioning. Keeping the entire stadium lights on full blast for a handful of people. It’s a costly insurance policy that often doesn’t pay off, and more importantly, it doesn’t inherently make you faster or more adaptable to new market demands.
The Power of Distributed Strength in Microservices
Microservices architecture offers a more elegant and strategically advantageous solution. Build specialized teams, each owning a key capability. Catalog. Recommendations. Payments. Each operates independently, allowing for parallel development and faster iteration cycles. When a new feature needs to be rolled out in the catalog service, it can be developed and deployed without requiring a full system update, significantly accelerating time-to-market. This agility allows businesses to respond rapidly to customer needs and gain a competitive edge. (Richardson)
Netflix, a veteran of the digital frontier, learned this lesson early. The monolithic path was a scaling dead end and a speed inhibitor. Their move to microservices wasn’t just a tech upgrade; it was a strategic embrace of resilience through distribution; the ability to innovate and release features at an unprecedented pace, fueling their exponential growth. Small hiccups in one area don’t disrupt the whole experience, and new ideas can be tested and deployed rapidly. (Netflix TechBlog)
Designing for Connection: The API-First Approach in Microservices
How do these independent pieces work together seamlessly and quickly? Through clear, intentional conversations: API-first development. Design the way they’ll communicate before you build the individual components. This creates clarity, allows teams to move in parallel without waiting on each other, and builds an agile digital platform where every part knows its role and how to connect efficiently. It’s like planning the routes before the explorers set out, ensuring everyone knows the destination and the path. This parallel development directly translates to faster feature releases and quicker responses to market opportunities.
Letting the Cloud Be the Engine: Focus on What Truly Matters
Now, imagine taking away even the worry of the underlying machinery. That’s the quiet power of serverless. AWS serverless lets you build microservices that scale effortlessly with demand. The infrastructure fades into the background, allowing your team to focus purely on delivering value. (AWS Serverless)
For that Black Friday rush, serverless microservices architecture means your checkout scales automatically, behind the scenes. No frantic manual adjustments needed. No late-night fire drills to spin up more servers. The system breathes with the demand, then gently settles back. Smart. Efficient. The hallmark of truly scalable software systems.
The Unseen Hand: Orchestrating Complexity into a Smooth Experience
A network of independent services needs coordination. A service mesh acts like the subtle conductor of your microservices orchestra. It manages the flow of requests, enforces the rules, and provides the insights you need to understand the intricate performance and identify areas for optimization that can support growth. (Service Mesh Ultimate Guide)
Spotify, masters of delivering seamless audio at scale, rely on deep visibility into their vast microservices landscape. Understanding the connections and performance is key to ensuring a smooth experience for millions and identifying opportunities to personalize and enhance the user experience, directly contributing to user retention and growth. (Spotify Engineering)
The Future Isn’t About Size, It’s About Smart Evolution
This move to microservices, powered by API-first development, the agility of serverless, and the orchestration of a service mesh, isn’t about adding complexity for its own sake. It’s about building a digital foundation that’s inherently more adaptable, more resilient, and ultimately, more reliable for your users. Driving business growth through faster time-to-market and the ability to quickly respond to evolving customer needs. It’s the core of intelligent enterprise modernization that directly impacts the bottom line.
R Systems helps enterprises navigate this crucial evolution. We see beyond the technology to the fundamental shift in how value is created and delivered in the digital age. It’s about empowering your teams and your architecture to be nimble, responsive, and ready for whatever comes next.
As the world of smart TVs evolves, delivering immersive and seamless viewing experiences is more crucial than ever. At Velotio Technologies, we take pride in our proven expertise in crafting high-quality TV applications that redefine user engagement. Over the years, we have built multiple TV apps across diverse platforms, and our mastery of cutting-edge JavaScript frameworks, like EnactJS, has consistently set us apart.
Our experience extends to WebOS Open Source Edition (OSE), a versatile and innovative platform for smart device development. WebOS OSE’s seamless integration with EnactJS allows us to deliver native-quality apps optimized for smart TVs that offer advanced features like D-pad navigation, real-time communication with system APIs, and modular UI components.
This blog delves into how we harness the power of WebOS OSE and EnactJS to build scalable, performant TV apps. Learn how Velotio’s expertise in JavaScript frameworks and WebOS technologies drive innovation, creating seamless, future-ready solutions for smart TVs and beyond.
This blog begins by showcasing the unique features and capabilities of WebOS OSE and EnactJS. We then dive into the technical details of my development journey — building a TV app with a web-based UI that communicates with proprietary C++ modules. From designing the app’s architecture to overcoming platform-specific challenges, this guide is a practical resource for developers venturing into WebOS app development.
What Makes WebOS OSE and EnactJS Stand Out?
Native-quality apps with web technologies: Develop lightweight, responsive apps using familiar HTML, CSS, and JavaScript.
Optimized for TV and beyond: EnactJS offers seamless D-pad navigation and localization for Smart TVs, along with modularity for diverse platforms like automotive and IoT.
Real-time integration with system APIs: Use Luna Bus to enable bidirectional communication between the UI and native services.
Scalability and customization: Component-based architecture allows easy scaling and adaptation of designs for different use cases.
Open source innovation: WebOS OSE provides an open, adaptable platform for developing cutting-edge applications.
What Does This Guide Cover?
The rest of this blog details my development experience, offering insights into the architecture, tools, and strategies for building TV apps:
R&D and Designing the Architecture
Choosing EnactJS for UI Development
Customizing UI Components for Flexibility
Navigation Strategy for TV Apps
Handling Emulation and Simulation Gaps
Setting Up the Development Machine for the Simulator
Setting Up the Development Machine for the Emulator
Real-Time Updates (Subscription) with Luna Bus Integration
Packaging, Deployment, and App Updates
R&D and Designing the Architecture
The app had to connect a web-based interface (HTML, CSS, JS) to proprietary C++ services interacting with system-level processes. This setup is uncommon for WebOS OSE apps, posing two core challenges:
Limited documentation: Resources for WebOS app development were scarce.
WebAssembly infeasibility: Converting the C++ module to WebAssembly would restrict access to system-level processes.
Solution: An Intermediate C++ Service capable of interacting with both the UI and other C++ modules
To bridge these gaps, I implemented an intermediate C++ service to:
Communicate between the UI and the proprietary C++ service.
Use Luna Bus APIs to send and receive messages.
This approach not only solved the integration challenges but also laid a scalable foundation for future app functionality.
Architecture
The WebApp architecture employs MVVM (Model-View-ViewModel), Component-Based Architecture (CBA), and Atomic Design principles to achieve modularity, reusability, and maintainability.
App Architecture Highlights:
WebApp frontend: Web-based UI using EnactJS.
External native service: Intermediate C++ service (w/ Client SDK) interacting with the UI via Luna Bus.
Block Diagram of the App Architecture
Choosing EnactJS for UI Development
With the integration architecture in place, I focused on UI development. The D-pad compatibility required for smart TVs narrowed the choice of frameworks to EnactJS, a React-based framework optimized for WebOS apps.
Why EnactJS?
Built-in TV compatibility: Supports remote navigation out-of-the-box.
React-based syntax: Familiar for front-end developers.
Customizing UI Components for Flexibility
EnactJS’s default components had restrictive customization options and lacked the flexibility for the desired app design.
Solution: A Custom Design Library
I reverse-engineered EnactJS’s building blocks (e.g., Buttons, Toggles, Popovers) and created my own atomic components aligned with the app’s design.
This approach helped in two key ways:
Scalability: The design system allowed me to build complex screens using predefined components quickly.
Flexibility: Complete control over styling and functionality.
Navigation Strategy for TV Apps
In the absence of any recommended navigation tool for WebOS, I employed a straightforward navigation model using conditional-based routing:
High-level flow selection: Determining the current process (e.g., Home, Settings).
Step navigation: Tracking the user’s current step within the selected flow.
This conditional-based routing minimized complexity and avoided adding unnecessary tools like react-router.
Handling Emulation and Simulation Gaps
The WebOS OSE simulator was straightforward to use and compatible with Mac and Linux. However, testing the native C++ services needed a Linux-based emulator.
The Problem: Slow Build Times Cause Slow Development
Building and deploying code on the emulator had long cycles, drastically slowing development.
Solution: Mock Services
To mitigate this, I built a JavaScript-based mock service to replicate the native C++ functionality:
On Mac, I used the mock service for rapid UI iterations on the Simulator.
On Linux, I swapped the mock service with the real native service for final testing on the Emulator.
This separation of development and testing environments streamlined the process, saving hours during the UI and flow development.
Setting Up the Development Machine for the Simulator
To set up your machine for WebApp development with a simulator, ensure you install the VSCode extensions — webOS Studio, Git, Python3, NVM, and Node.js.
Install WebOS OSE CLI (ares) and configure the TV profile using ares-config. Then, clone the repository, install the dependencies, and run the WebApp in watch mode with npm run watch.
Install the “webOS Studio” extension in VSCode and set up the WebOS TV 24 Simulator via the Package Manager or manually. Finally, deploy and test the app on the simulator using the extension and inspect logs directly from the virtual remote interface.
Note: Ensure the profile is set to TV because the simulator only works only for the TV profile.
ares-config --profile tv
Setting Up the Development Machine for the Emulator
To set up your development machine for WebApp and Native Service development with an emulator, ensure you have a Linux machine and WebOS OSE CLI.
Install essential tools like Git, GCC, Make, CMake, Python3, NVM, and VirtualBox.
Build the WebOS Native Development Kit (NDK) using the build-webos repository, which may take 8–10 hours.
Configure the emulator in VirtualBox and add it as a target device using the ares-setup-device. Clone the repositories, build the WebApp and Native Service, package them into an IPK, install it on the emulator using ares-install, and launch the app with ares-launch.
Setting Up the Target Device for Ares Command to be Able to Identify the Emulator
This step is required before you can install the IPK to the emulator.
Note: To find the IP address of the WebOS Emulator, go to Settings -> Network -> Wired Connection.
Real-Time Updates (Subscription) with Luna Bus Integration
One feature required real-time updates from the C++ module to the UI. While the Luna Bus API provided a means to establish a subscription, I encountered challenges with:
Lifecycle Management: Re-subscriptions would fail due to improper cleanup.
Solution: Custom Subscription Management
I designed a custom logic layer for stable subscription management, ensuring seamless, real-time updates without interruptions.
Packaging, Deployment, and App Updates
Packaging
Pack a dist of the Enact app, make the native service, and then use the ares-package command to build an IPK containing both the dist and the native service builds.
npm run packcd com.example.app.controllermkdir BUILDcd BUILDsource /usr/local/webos-sdk-x86_64/environment-setup-core2-64-webos-linuxcmake ..makeares-package-n app/dist webos/com.example.app.controller/pkg_x86_64
Deployment
The external native service will need to be packaged with the UI code to get an IPK, which can then be installed on the WebOS platform manually.
WebOS OSE 2.0.0+ supports Firmware-Over-the-Air (FOTA) using libostree, a “git-like” system for managing Linux filesystem upgrades. It enables atomic version upgrades without reflashing by storing sysroots and tracking filesystem changes efficiently. The setup involves preparing a remote repository on a build machine, configuring webos-local.conf, and building a webos-image. Devices upgrade via commands to fetch and deploy rootfs revisions. Writable filesystem support (hotfix mode) allows temporary or persistent changes. Rollback requires manually reconfiguring boot deployment settings. Supported only on physical devices like Raspberry Pi 4, not emulators, FOTA simplifies platform updates while conserving disk space.
Key Learnings and Recommendations
Mock Early, Test Real: Use mock services for UI development and switch to real services only during final integration.
Build for Reusability: Custom components and a modular architecture saved time during iteration.
Plan for Roadblocks: Niche platforms like WebOS require self-reliance and patience due to limited community support.
Conclusion: Mastering WebOS Development — A Journey of Innovation
Building a WebOS TV app was a rewarding challenge. With WebOS OSE and EnactJS, developers can create native-quality apps using familiar web technologies. WebOS OSE stands out for its high performance, seamless integration, and robust localization support, making it ideal for TV app development and beyond (automotive, IOT, and robotics). Pairing it with EnactJS, a React-based framework, simplifies the process with D-pad compatibility and optimized navigation for TV experiences.
This project showed just how powerful WebOS and EnactJS can be in building apps that bridge web-based UIs and C++ backend services. Leveraging tools like Luna Bus for real-time updates, creating a custom design system, and extending EnactJS’s flexibility allowed for a smooth and scalable development process.
The biggest takeaway is that developing for niche platforms like WebOS requires persistence, creativity, and the right approach. When you face roadblocks and there’s limited help available, try to come up with your own creative solutions, and persist! Keep iterating, learning, and embracing the journey, and you’ll be able to unlock exciting possibilities.
The client, an Eastern European MVNO, faced challenges with its charging gateway, which was built on legacy architecture and was nearing its end of life.
The platform was playing a vital role in operations, managing credit control and billing mediation, so migrating to a future-proof solution ensured the client could continue to deliver high-quality services to its subscribers. By deploying in AWS within days, leveraging AI-driven automation, and ensuring zero-downtime migration, the MVNO achieved:
50% boost in operational efficiency
Significant OPEX reduction
Seamless integration with core network elements
With RSI Quasar Application Engine Platform as a secure and reliable technological foundation, the client experienced the transformative power of a cloud-based, future-proof solution.
Discover how this transformation enabled faster service delivery, improved scalability, and unlocked long-term cost savings.
By migrating their monolithic IPTV solution and integrating it with a microservices-based OTT platform, the client achieved a scalable, cost-efficient, and future-ready system.
The successful integration aimed to reduce costs, diminish operational complexity and streamline operations, while maintaining exceptional service quality. The modernization also enhanced the platform’s marketability, unlocking new revenue opportunities, which positioned the client as a leader in offering innovative solutions to media and entertainment providers.
Results Delivered
Cost Savings: Unified operations and database migration reduced expenses significantly
Enhanced Scalability: Processed sensitive data for millions of users efficiently with modular microservices
Improved Marketability: adding NPVR feature as SaaS unlocked new revenue streams
Operational Excellence: Streamlined redundant tasks and enhanced monitoring for better customer experience
Reliability: Achieved five nines (99.999%) uptime with zero downtime since deployment.
Our client, a leading US mobile telecom operator serving millions of subscribers, experienced the transformative power of innovative system architecture. Through strategic collaboration and commitment to deliver excellence, they have successfully modernized their provisioning system, critical for real-time service updates and customer profile management.
Leveraging our long-time partnership and knowledge about our client’s business, we proposed a modernization approach: transitioning to a microservices architecture. This allowed them to continue delivering exceptional service to their clients, while maintaining excellent standards of efficiency and scalability.
This was due to the substantial operational and cost benefits resulting from this project:
Operational Cost Reduction: Lower resource utilization (from 80% to under 50%), eliminating planned hardware expansion
Enhanced Service Delivery: Real-time notifications reduced alert latency from minutes to seconds
Future-Ready Scalability: Supported 30% subscriber growth without hardware investments
A major telecom operator in Western Europe, serving over 6 million subscribers, went through a digital transformation that transcended typical system upgrades. By reimagining their Voucher and Reload Management System, initially built on monolithic architecture, our client not only resolved their immediate operational challenges, but also got a dynamic, scalable platform, which positioned them for sustained growth.
The modernization process shows how strategic technological innovation has the power to reshape an organization’s operational capabilities, turning constraints into opportunities. Leveraging the benefits of microservices architecture, our approach allowed them to overcome legacy constraints and reduce costs.
Results Delivered
100% uptime since launch and zero customer support incidents
Successful management of 6+ million customer data records
Eliminated database licensing costs, saving resources for growth initiatives
Enhanced security due to robust architecture and technology stack
Future-ready system supporting seamless scalability and operational efficiency
The transformation from monolithic architecture to microservices positions organizations at the forefront of digital innovation. By implementing cloud-native solutions and microservices architecture, businesses can significantly enhance their agility, scalability, and security. This strategic shift not only strengthens competitive advantage but ensures long-term success in today’s rapidly evolving digital landscape!
Key Insights from Our POV Article:
Enhanced ability to update and deploy individual components independently
Reduced system-wide impact during updates
Targeted scaling of specific components during peak demands
Regional scalability for global operations
Improved performance during high-traffic periods
Reduced attack surface through service isolation
Enhanced protection against system-wide vulnerabilities
Seamless integration with cloud infrastructure
Cross-cloud deployment flexibility
Enhanced system resilience through service compartmentalization
Improved scalability through elastic infrastructure
Optimized resource usage with on-demand scaling
According to IDC, 85% of enterprises are adopting these modern architectures to remain competitive.
To learn more about transforming your Microservices, fill out the form to access the full PoV article!
The world has shifted to a digital-first economy, and seamless operations are important to the success of a business. The key to thriving in this environment is anticipating challenges before they cause business disruption, financial loss, erosion of customer trust, and long-term reputational damage.
Chaos Engineering, a practice of intentionally introducing failure into systems to test their resilience, integrated with DRaaS, offers a powerful solution to ensure operational continuity and enhance resilience. Our latest Point of View (POV) document explores how businesses can apply this model to create more reliable, adaptable systems that thrive under pressure.
Key Insights from Our POV Document
Acknowledging Weaknesses: Identify vulnerabilities and begin the resilience journey with Chaos Engineering as your guide.
Proactive Over Reactive: Shift from disaster recovery to resilience strategies that anticipate and mitigate risks.
Chaos Engineering Redefined: Move beyond testing reliability to driving continuous improvement and adaptability.
Real-World Testing with Game Days: Simulate failures in structured events to uncover resilience insights.
Continuous Validation: Automate resilience testing in CI/CD pipelines for ongoing improvement.
Safe Experimentation: Use canary deployments to scale Chaos Engineering gradually and safely.
Multi-Cloud Resilience: Test failovers and interdependencies to manage multi-cloud complexities.
Build Resilient Systems Today Fill out the form to download our POV document and gain actionable strategies to ensure operational continuity and thrive under pressure.
