Case study
Digital Experience Layer
Web and mobile journeys were waiting on slow enterprise reads. I helped architect a separate digital data layer and led 30+ engineers across 16 delivery teams as DXL grew to about 200 services.
Vodafone Greece · Kubernetes · Microservices · Quarkus
Before
A critical API scenario took 15 seconds, waiting on enterprise systems.
After
The same scenario took 150 ms, with reads served from the digital data layer.
Building a real-time digital layer over enterprise systems
Vodafone Greece’s enterprise systems had been built to run the business reliably for years. They were systems of record — not systems designed to serve modern mobile and web experiences.
The challenge was not simply to expose them through REST.
Digital journeys required low latency, large amounts of data aggregation, resilience to sudden traffic spikes, and the ability for multiple product teams to evolve independently. Making every customer request travel through a chain of enterprise systems would preserve the same performance and coupling problems behind a newer API.
The Digital Experience Layer — DXL — was built to change that.
It evolved into a Kubernetes-based microservices platform sitting between Vodafone’s digital channels and its Corporate IT systems, providing both a modern API layer and a read-optimized digital representation of enterprise data.
The architectural idea
One of the most important decisions behind DXL was to stop treating Corporate IT systems as databases for digital journeys.
Instead, we applied CQRS principles and built what we called the Digital Datastore.
Enterprise systems remained the source of truth. Changes in their databases were captured and streamed through Kafka. A set of dedicated microservices consumed those changes, transformed enterprise data into models designed for digital use cases, and materialized them in MongoDB.
Digital APIs could then query data that was already shaped for their access patterns rather than reconstructing a customer view from multiple enterprise systems on every request.
Transactional operations could still reach the systems of record when required. Reads — by far the dominant part of many digital journeys — could be served independently.
This architecture did more than cache responses.
It decoupled the read characteristics of digital products from the operational characteristics of the systems behind them.
It reduced calls against backend systems by an order of magnitude in documented cases and made complex customer journeys possible without paying the latency cost of repeatedly traversing the enterprise stack.
Designing for traffic, not just functionality
Vodafone traffic is inherently bursty.
A campaign sent to customers can cause a large number of users to open the application within minutes. Individual digital journeys may also require information from several services before a response can be constructed.
That shaped another architectural principle of DXL: I/O should be parallel by default.
Instead of sequentially calling downstream systems, services were designed around asynchronous and reactive execution. Reactor, RxJava and later Mutiny were used across different generations of the platform to compose parallel operations efficiently.
It was not unusual for a service to aggregate data from many other services as part of a single journey. Parallel I/O was therefore not an optimization added afterwards; it became part of the development model itself.
Building an engineering platform around the architecture
At this scale, the individual microservice was only part of the problem.
Dozens of teams repeatedly needed the same capabilities: authentication, authorization, logging, monitoring, database connectivity, Kafka integration, request propagation and other cross-cutting concerns.
We moved these capabilities into a common library infrastructure maintained much like an internal open-source project.
Application teams became both users and contributors.
The objective was simple: business services should contain business logic — not another implementation of the platform around them.
This gave teams a consistent engineering model while still allowing them to deploy and evolve their services independently.
Rethinking the Java runtime
As DXL grew, another bottleneck became visible.
Our original Spring Boot services were optimized aggressively, but their memory footprint and startup characteristics were increasingly important in a Kubernetes environment.
Slow startup is not merely an inconvenience when applications autoscale. During a sudden traffic spike, the time between requesting additional replicas and those replicas becoming ready directly affects the health of the system.
In 2019, we began evaluating alternatives including Node.js, Go, Vert.x, Micronaut and Quarkus.
We ultimately adopted Quarkus and rebuilt our common infrastructure around it.
One production use case presented publicly showed the difference:
| Spring Boot | Quarkus | |
|---|---|---|
| Memory | ~800 MB | ~360 MB |
| CPU | ~500 mCPU | ~300 mCPU |
| Startup | ~40 sec | ~14 sec |
| Production replicas under load | up to 12 | 2–4 |
The service handled roughly 4–5 million requests per day with heavy traffic spikes of 100K requests per minute.
The migration also eliminated a significant amount of framework and infrastructure glue code and gave developers a much faster development feedback loop.
The significance of the migration was not Quarkus itself.
It was recognizing that application architecture, runtime characteristics and developer experience were all parts of the same scalability problem.
My role
I joined Vodafone Greece as the backend organization behind DXL was still very small and helped grow both the platform and the engineering practice around it.
As Chapter Leader for API Development and DXL technical lead, I led a chapter of 30+ engineers across 16 teams while staying involved in architecture and hands-on engineering.
I helped shape the CQRS and microservice architecture, drove the evolution of our shared engineering infrastructure, led the evaluation and adoption of Quarkus, and established patterns for reactive development and parallel I/O.
I mentored engineers into technical leads, defined career growth paths, and established shared engineering standards and delivery practices. Making architectural decisions reusable across teams meant giving engineers both common tools and the support to take ownership of their services.
What began as a relatively small microservices initiative grew into a platform supporting dozens of engineers and development teams, eventually reaching about 200 production microservices. (A 2023 Vodafone Tech article documented 170 services at publication; the platform continued to grow from there.)
Sharing what we learned
The work around DXL and our Java modernization became a reference point outside Vodafone Greece as well.
I presented the journey at Red Hat Summit, discussed it with Red Hat engineers in public sessions and Quarkus Insights, and was interviewed about the architecture and migration by InformationWeek and The New Stack.
In 2023, I co-presented “Battle of the Frameworks: Quarkus vs Spring Boot” at Devoxx Greece with Red Hat’s Georgios Andrianakis, revisiting the architectural and runtime decisions several years after the original migration.
Selected coverage & talks
- Devoxx Greece — Battle of the Frameworks: Quarkus vs Spring Boot, 2023
- The New Stack — How Vodafone Greece Built 80 Java Microservices in Quarkus, 2021
- Quarkus Insights #33 — Vodafone Greece, 2021
- Red Hat — Vodafone Greece’s migration journey from Spring Boot to Quarkus, 2020
- InformationWeek — Why Vodafone Greece Devs Migrated to Red Hat’s Quarkus, 2020
- Red Hat Summit, 2020
- Quarkus Blog — Vodafone Greece replaces Spring Boot with Quarkus, 2019
Media & further reading
Battle of the Frameworks: Quarkus vs Spring Boot
Watch Battle of the Frameworks on YouTube
Quarkus Insights #33
Watch Quarkus Insights #33 on YouTube
Vodafone Greece’s migration journey from Spring Boot to Quarkus
Watch the Red Hat fireside chat on YouTube
The resource cards below provide the source article, talks, interview, and Quarkus post.
Media & further reading
article
Building microservices middlewares in Vodafone
video
Battle of the Frameworks: Quarkus vs Spring Boot
video
Quarkus Insights #33
video
Vodafone Greece's migration journey from Spring Boot to Quarkus
interview
How Vodafone Greece Built 80 Java Microservices in Quarkus
article
Vodafone Greece replaces Spring Boot with Quarkus