The Software House was chosen to build a centralized subscription management system that could handle millions of requests while maintaining speed and reducing load on third-party suppliers.
As Zinio's digital magazine platform grew, their infrastructure struggled to keep up with the volume. Millions of requests were pinging back and forth between their apps and third-party content suppliers, creating inefficiencies. They needed a way to consolidate all subscription data into one system that could scale with their growing user base.
Partnership goal:
→ Build a fast, scalable backend API that aggregates subscription data, reduces redundant third-party requests, and creates a centralized database for all subscription information.
Zinio
Zinio is a digital magazine distribution platform that converts print publications into digital products. The company gives publishers the tools to enhance and sell their content through multiple digital channels, including Zinio's own newsstand, helping them adapt to the decline of traditional print media.
INDUSTRY
Digital Publishing / Media Technology
COUNTRY
Spain
SERVICE PROVIDED
Backend API Development, DevOps
Challenge
Print magazines have been losing ground for years, pushing publishers to find new ways to reach readers online. But building your own digital distribution isn't simple. Zinio stepped in to solve that problem by creating a platform that transforms magazines into digital products and distributes them across multiple channels.
As the platform grew and more publishers came on board, the underlying architecture started showing cracks. The system was handling millions of requests - from users accessing content through Zinio's apps, to third-party suppliers delivering that content, and back again. Each request created more load, and the same data was often requested multiple times from third parties, wasting resources and slowing things down.
Zinio needed a solution that would:
-> Handle millions of requests from their apps efficiently
-> Communicate with external content suppliers seamlessly
-> Aggregate all subscription data in one centralized location
-> Scale with high service load without performance degradation
-> Reduce redundant requests to third-party systems for the same data
-> Process synchronization asynchronously to improve speed
Solution
The Software House approached this as an architecture problem that required both smart design and the right technology choices. The solution centered on building a backend API that would act as an intelligent intermediary - receiving requests from Zinio's apps, coordinating with external suppliers, and feeding everything into a centralized database.
The key was making the system asynchronous. Instead of waiting for each request to complete before moving to the next one, the API could handle multiple operations simultaneously. This was achieved using Redis and RabbitMQ as message brokers, which allowed the system to queue and process requests efficiently without blocking. The result was an architecture that could handle significantly more traffic while using less processing power than before.
Process
The team faced a tight deadline but prioritized building a solution that would meet Zinio's high-performance requirements. The architecture was designed from the ground up to handle scale.
Asynchronous Processing Implementation
The biggest technical challenge was redesigning the entire subscription sync process to work asynchronously. In the old system, requests would wait in line, creating bottlenecks. The new design uses RabbitMQ to queue incoming requests and Redis to cache frequently accessed data, dramatically reducing the need to repeatedly hit third-party APIs for the same information.
Centralized Data Architecture
Rather than having subscription data scattered across multiple systems, the team built a single source of truth. All subscription information now flows into one centralized database, making it easier to maintain data consistency, run analytics, and troubleshoot issues when they arise.
Outcome
Zinio now runs on a scalable architecture that processes user and subscription data more efficiently while using less processing power than before.
→ Reduced infrastructure load: The system significantly cuts down redundant requests to third-party suppliers by caching and centralizing data.
→ Future-proof scalability: The architecture handles current traffic and is designed to scale with Zinio's growth without performance degradation.
→ Faster response times: Asynchronous processing and intelligent caching deliver subscription data to users more quickly than the previous system.
