Skip to content
Christos Sotiriou
All work

Case study

C.E.L.L.

Exposing an API could take up to two weeks of coordination. I architected C.E.L.L. and led its 10-person team to turn those manual steps into software, bringing API exposure down to about three seconds.

Vodafone Greece · Platform Engineering · Kubernetes · TM Forum ODA

Company
Vodafone Greece
Period
2022–2025
Role
Principal Architect & Engineering Lead

Before

Exposing an API meant manual configuration and up to two weeks of coordination.

After

A component declares what it needs; the platform exposes its API in about three seconds.

C.E.L.L. architecture: a component manifest is reconciled by Canvas operators into gateway, identity and event configuration

C.E.L.L. (Componentized Enterprise Logical Layer) started with a practical decision: let an application declare the infrastructure it needs, and let the platform configure it. Instead of passing tickets between teams, engineers could describe their APIs, identity and event requirements in a component manifest.

I led the architecture and the 10-person team that built it at Vodafone Greece between 2022 and 2025, using Kubernetes operators and TM Forum’s Open Digital Architecture (ODA). The work included turning operational policies into executable automation and adopting ODA while its reference implementation was still evolving.


The challenge: the hidden cost of enterprise operations

Vodafone Greece’s Core IT landscape includes more than 150 systems, spanning CRM, billing, payments, and operational support. Many are business-critical systems that cannot simply be replaced or taken offline while the organization modernizes. Over time, the technical estate—and the number of teams and processes needed to maintain it—had grown substantially.

Our earlier work on the Digital eXperience Layer (DXL) had already demonstrated what microservices and API-led integration could achieve. But scaling DXL beyond 200 services, with many teams contributing to the same platform, also revealed an uncomfortable truth: modular software does not necessarily lead to modular operations.

Consider a typical enterprise release. One team builds an API. Another configures the API gateway. A separate team may provision a database or update network resources. Security and identity teams validate access, while release and operations teams coordinate the production rollout. Each activity can be justified individually; together they create waiting time, duplicated effort, and substantial operating cost.

A feature that takes three weeks to develop might spend another three navigating configurations, dependencies, and operational hand-offs before reaching production—without adding any business value. That is an illustrative scenario, but the underlying bottleneck was measurable: in Vodafone’s case, manual API exposure alone could take up to two weeks.

The critical question was therefore not how do we make developers write services faster? It was how do we stop making people repeatedly perform work that the organization already knows how to do?

The answer was to formalize those procedures as declarative policies and executable automation. Rather than handing a ticket to the next team, a component could declare what it needed—and the platform could bring the environment into the required state.

BEFORE · ONE BUCKETBillingServiceManagementOrderManagementProvisioningCustomerReportingshared dbscriptscroncomponentizeAFTER · COMPONENTSAPIBilling/billingAPIServiceManagement/servicesAPICustomerReporting/reportsAPIOrderManagement/ordersAPIProvisioning/provisioning+ next componentplatform · gateway · identity · events
everything in one bucketcomponents with contracts

The vision: from microservices to Composable IT

From componentization and automation toward AI-driven orchestration

Composable IT treats enterprise functionality as independent, reusable capabilities that can be assembled, deployed, and operated through well-defined contracts. It extends the promise of microservices beyond application decomposition into the way infrastructure and organizational policies are managed.

For CELL, this meant moving from a collection of individually managed services toward self-contained business and technical components, with explicit interfaces, independent release lifecycles, and a declarative integration model. A component could group multiple collaborating microservices and expose its capabilities through REST APIs, without every change requiring coordination across shared deployments.

Where teams needed to reuse code, the InnerSource model allowed them to share implementations while maintaining independent deployed instances and release schedules. This intentionally traded some runtime reuse for reduced cross-team coupling.

But componentization was only part of the answer. To reduce operational overhead, we needed the platform to understand what each component required and configure its surroundings automatically. Enterprise policy had to become executable, not simply documented.

CELL's component-oriented development and deployment model

Adopting ODA before the blueprint was finished

This direction was not invented in isolation. Vodafone Group was a major force behind the development of TM Forum’s Open Digital Architecture and ODA Canvas, helping shape the industry-wide approach to component-based, cloud-native telecom IT. CELL aligned with that strategic direction from the outset.

The timing made the work unusual. When we began adopting ODA in 2022, the ODA Canvas specification and open-source reference implementation were still evolving. We were not integrating a mature product with an established operational playbook. We were turning an emerging architecture into a functioning production platform.

Vodafone Greece became the first Vodafone market to implement ODA Canvas in a live commercial environment, and one of its early adopters worldwide—before the reference implementation became generally available in 2025. This early deployment was documented by TM Forum in its interview about CELL and in its industry announcement.

As an early adopter and implementation-side contributor, I worked closely with Vodafone Group’s ODA stakeholders, regularly exchanging architectural feedback and implementation knowledge. We adopted the ODA component and Canvas model while adapting the implementation where Vodafone Greece needed different integrations, additional security hardening, or production-specific behavior.

This mattered because early adoption was not simply about following a specification. It required architectural judgment: which parts of the emerging standard to adopt, where to extend it, and how to preserve the common model without compromising operational requirements.


The architecture: turning intent into infrastructure

I designed CELL around the ODA Component and ODA Canvas concepts, using Kubernetes Custom Resources and purpose-built Operators to connect application intent to operational behavior.

At the center is the CELL / ODA Component: a standardized deployment unit that packages collaborating business services alongside a machine-readable manifest. The manifest declares the component’s required integrations—such as API exposure, authentication, authorization, and published or subscribed events—without embedding the concrete configuration of each target environment into its business code.

The CELL Canvas is our implementation of the ODA Canvas model. Its Kubernetes Operators watch these declarations and reconcile the required state: creating or updating gateway routes, integrating with identity services, and applying the supported platform configurations. Deploying a component therefore initiates an automated process that previously required separate teams and manual operational procedures.

This is more than infrastructure scripting. The organization’s operational knowledge becomes versioned, executable platform behavior. Instead of telling another team how to configure the environment, developers state what their component needs. The Canvas determines how those requirements are satisfied in that environment.

Kubernetes Operators reconcile declared intent with cluster state

The platform combines several technologies, each serving a distinct architectural purpose:

  • Kubernetes and Helm: Component packaging, deployment, and orchestration.
  • Custom Kubernetes Operators: Declarative lifecycle management and infrastructure reconciliation.
  • Java, Quarkus, and Java Operator SDK: Business services and custom platform controllers.
  • Apache APISIX and Keycloak: API exposure, authentication, and identity management.
  • Terraform and Argo CD: Infrastructure provisioning and GitOps-based application delivery.

Automation is not an afterthought around CELL. It is part of its architecture: policies are expressed through declarative contracts and enforced through reconciliation logic. Procedures that once lived in runbooks, tickets, and tribal knowledge can be implemented once in the platform and applied consistently across components. The aim is to reduce repeated manual work while retaining centralized control over enterprise security and operations.

From clusters to declarative control planes

One business capability, different Vodafone markets

A multinational enterprise introduces another form of complexity. Different Vodafone markets may run different gateway technologies, identity systems, network configurations, operational policies, and legacy integrations. Without a consistent platform abstraction, these differences tend to leak into application code: environment-specific configuration paths, conditional behavior, and assumptions about the infrastructure surrounding each service.

That makes software harder to reuse. A microservice built for one market may need modifications before another market can deploy and operate it—even when the business capability is essentially the same.

The ODA model offers a way to separate these responsibilities. The component owns the business logic and declares its requirements; the Canvas owns how those requirements are implemented in the target environment. For example, an ODA component can declare that an API must be exposed and protected, without hard-coding the target market’s gateway routes or identity-provider integration.

A Canvas implementation in each environment can then translate the same component contract into its own infrastructure and policy configuration. The goal is to let engineers focus on business capabilities rather than repeatedly solving gateway, identity, and deployment concerns for each market.

This is not a promise that arbitrary services will run unchanged everywhere: data dependencies, regulatory requirements, external interfaces, and Canvas capabilities still have to be addressed. It is a deliberate architectural boundary that makes portability and reuse much more achievable. The same principle also improves consistency across test, staging, and production environments within a single market.


Engineering impact

The clearest results were operational, because operational overhead was the problem we had set out to address.

API exposure: from up to two weeks to approximately three seconds.

Previously, a new API exposure could require coordination, implementation, and configuration work across multiple teams. With CELL Canvas, deploying a component with the appropriate declaration triggers automated API gateway and identity integration. This is the published comparison for API exposure—not a claim that an entire feature goes from development to production in three seconds.

Automated API exposure through CELL Canvas operators

Complete cluster replication: approximately 16 minutes.

Terraform, Argo CD, and CELL Canvas together enabled a full cluster replica, including the applications and their API gateway exposure, to be brought up in approximately 16 minutes. This made temporary test and regression environments substantially easier to reproduce.

The effect extends beyond these two metrics. Turning environment operations into reusable software reduces the amount of coordination required per deployment, prevents configuration knowledge from being scattered across teams, and supports a more consistent operational model. Although we did not publish a single organization-wide cost-saving percentage, lower operational effort and faster delivery were central outcomes.


Beyond automation: preparing the enterprise for AI

CELL was designed to solve immediate enterprise problems, not to market an AI product. But the architectural direction has a longer-term consequence.

Before an organization can reliably use AI to orchestrate business operations, its capabilities need to be discoverable, accessible through stable interfaces, governed by security policies, and backed by repeatable execution mechanisms. In many enterprises, those capabilities are still hidden behind manual procedures, tightly coupled applications, and environment-specific integrations.

Composable IT offers a progression: organize capabilities into components, express them through APIs, formalize operational policies, and automate their execution. Once those foundations exist, intelligent systems have clearer and safer mechanisms through which they may eventually interact with the enterprise.

CELL contributed to that foundation through standardized components, API exposure, declarative infrastructure configuration, and automation built into the control plane. It did not itself provide autonomous AI orchestration, and APIs alone are not sufficient: semantic discovery, authorization, observability, guardrails, and reliable execution are still required.

Nevertheless, the direction matters. Before an enterprise can become AI-driven, it must first become machine-operable. CELL was a practical step toward that state, by making operational capabilities explicit and executable rather than dependent on cross-team hand-offs.


My role and contribution

As CELL’s Principal Architect and Engineering Lead, I owned the architectural direction and built and led the 10-person engineering team. I worked with the CIO and senior technology leadership to connect modernization strategy with the team’s delivery priorities and engineering practices.

I stayed hands-on: I defined the component model and platform workflows, built the initial CELL Canvas implementation, and implemented Kubernetes Operator-based automation connecting application declarations with API gateway, identity, and infrastructure state. Beyond the local implementation, I collaborated regularly with Vodafone Group ODA stakeholders, exchanging practical engineering feedback while the architecture and Canvas specification were still evolving.

That combination—setting architectural direction, turning an emerging industry standard into production software, and leading its adoption inside a complex enterprise—was the central contribution of my role.

I presented CELL at the Athens Kubernetes Meetup and, alongside colleagues, at TM Forum’s DTW Ignite 2025 in Copenhagen. TM Forum also profiled the CELL deployment as an early commercial implementation of ODA Canvas.

DTW Ignite 2025 (1 of 2)DTW Ignite 2025 (2 of 2)
DTW Ignite 2025

Closing perspective

CELL was a response to a recurring enterprise problem: software can be modular while the organization operating it remains tightly coupled. Every manual configuration, environment-specific workaround, and cross-team hand-off increases the cost of change.

The most important design decision was to move that repeated operational knowledge into a shared, programmable platform—without taking ownership of business logic away from development teams.

Composable IT is not just about breaking systems into smaller pieces. It is about making those pieces portable, independently manageable, and governable through software. CELL demonstrated what that can mean in production: faster API exposure, reproducible environments, less operational friction, and a clearer foundation for future AI-driven orchestration.


Media & further reading

Athens Kubernetes Meetup Vol 22

Watch Athens Kubernetes Meetup Vol 22 on YouTube

The resource cards below link to the Vodafone engineering publications, DTW Ignite, TM Forum interview, and the composable-IT reflection on Kubernetes Operators.

ODA Canvas

TM Forum’s evolving ODA Canvas now also addresses AI-native runtime capabilities, extending the same ideas of component lifecycle automation and governance to AI agents. These are developments in the broader ODA ecosystem, not features claimed as delivered by the 2022–2025 CELL implementation.

Media & further reading