- The Monolith Pain Points
- The Migration Strategy That Actually Works
- GraphQL Gateways: The Unsung Hero
- Event-Driven Architecture with Kafka
- Kubernetes: When It Helps and When It Hurts
- Infrastructure Context: Nigeria vs Global
- The Database Challenge
- Monitoring and Observability
- Team Structure and Conway’s Law
- When Microservices Go Wrong
- Success Patterns That Work And Looking Forward
Ayodeji Erinfolami has led several monolith-to-microservices migrations across different organizations and geographies. His experiences span e-commerce platforms, and emerging fintech applications, giving him unique insights into when microservices actually solve problems versus when they create new ones.
“Everyone talks about microservices like they’re magic”, “but the reality is messier. You’re trading one set of problems for a completely different set of problems.”
His perspective is shaped by working in diverse environments from large organizations to startups with robust infrastructure to resource-constrained environments where every architectural decision has immediate cost implications.
The Monolith Pain Points
When asked about what drives teams toward microservices, Ayodeji doesn’t start with scalability or team independence. He starts with deployment fear.
“The biggest sign that you need to break up a monolith isn’t performance issues,” he explains. “It’s when your team is afraid to deploy. When a small change to the user interface requires testing the entire payment system, and fixing a bug in search might break checkout, that’s when you know you have a problem.”
He describes the classic symptoms: deploy cycles that take hours, unexpected regressions from seemingly unrelated changes, and teams stepping on each other’s work. “We had situations where fixing a typo in a marketing page required a full regression test of the entire platform because everything was so interconnected.”
But he’s quick to point out that not all monoliths need to become microservices. “Some monoliths are perfectly fine,” he notes. “If your team is small, your domain is well-understood, and you’re not having deployment or scaling issues, don’t fix what isn’t broken.”
The Migration Strategy That Actually Works
Most articles about microservices assume you’re building from scratch. Ayodeji’s experience is different, he’s always been extracting services from existing monoliths while keeping them running.
“You can’t just stop development for six months to rewrite everything,” he says. “The business doesn’t stop because you want better architecture.”
His approach follows what he calls the “strangler fig pattern” gradually extracting functionality while keeping the monolith operational. “You identify clear domain boundaries, build the new service alongside the monolith, then slowly move traffic over.”
The key insight is starting with the edges. “Don’t start with your most critical business logic,” he advises. “Start with things like user notifications, file uploads, or reporting. These are usually well-contained and failing gracefully doesn’t hurt the core business.”
He also emphasizes the importance of data migration strategy. “Everyone focuses on the application code, but the database is usually the hardest part,” he explains. “You need to plan how data flows between the old system and new services, and how you’ll eventually migrate completely.”
GraphQL Gateways: The Unsung Hero
One of Ayodeji’s strongest opinions is about API gateways, specifically GraphQL-based ones. “REST APIs become a nightmare in microservices,” he states bluntly. “You end up with frontend code making 15 different API calls to render a single page.”
His solution has consistently been GraphQL gateways using Apollo Server. “The gateway becomes your facade,” he explains. “Frontend teams get a single endpoint that gives them exactly the data they need, while backend services can evolve independently.”
But implementing GraphQL gateways isn’t trivial. “You need to think about caching, error handling, and how to compose data from multiple services,” he notes. “The gateway can become a bottleneck if you’re not careful.”
His approach involves schema stitching to combine different service schemas into a unified API. “Each microservice exposes its own GraphQL schema, and the gateway stitches them together,” he describes. “This way, service teams control their own API contracts, but frontend teams get a consistent interface.”
The performance implications are significant. “We typically see a lot of reduction in frontend API calls when we introduce a GraphQL gateway,” he says. “That translates to faster page loads and better user experience.”
Event-Driven Architecture with Kafka
When microservices need to communicate, Ayodeji consistently turns to event-driven patterns using Kafka. “Synchronous service-to-service calls create coupling,” he explains. “If Service A calls Service B directly, they’re not really independent anymore.”
Events solve the coupling problem but create new challenges. “Now you’re dealing with eventual consistency, message ordering, and idempotency,” he lists. “It’s more complex, but it’s the right kind of complexity.”
His Kafka implementations focus on domain events rather than data synchronization. “Don’t use events to keep databases in sync,” he advises. “Use events to communicate that something business-relevant happened. Other services can decide how to react.”
The event design requires careful thought. “You need to include enough information in the event so consuming services don’t need to call back to the producer,” he explains. “But not so much that you’re coupling services through the event schema.”
He also emphasizes the operational challenges. “Kafka is not fire-and-forget,” he warns. “You need monitoring, alerting, and strategies for handling failed message processing. The complexity is worth it, but don’t underestimate it.”
Kubernetes: When It Helps and When It Hurts
Ayodeji has deployed microservices both with and without container orchestration, giving him perspective on when Kubernetes actually adds value.
“Kubernetes solves real problems, but it also creates new ones,” he explains. “If you have a small team and simple deployment needs, Docker Compose might be enough. Don’t use Kubernetes just because everyone else is.”
When Kubernetes does make sense, the benefits are substantial. “Auto-scaling, rolling deployments, and service discovery become trivial,” he notes. “But you’re also adding operational complexity that someone on your team needs to understand.”
His adoption strategy is gradual. “Start with containerizing your applications first,” he advises. “Get comfortable with Docker, then consider orchestration when you actually need it.”
The learning curve is real. “Kubernetes has a steep learning curve, and debugging issues can be complex,” he admits. “Make sure you have team members who can handle the operational overhead.”
Infrastructure Context: Nigeria vs Global
Working across different geographic and economic contexts has given him unique insights into how infrastructure constraints affect architectural decisions.
“In some environments, bandwidth is expensive and connectivity is unreliable,” he explains. “Microservices assumptions about fast, cheap network communication don’t always hold.”
This reality affects service granularity decisions. “In bandwidth-constrained environments, you might aggregate related functionality into slightly larger services to reduce network chatter,” he notes. “The pure microservices ideal of very small, single-purpose services can be cost-prohibitive.”
Deployment strategies also change. “Where internet connectivity is unreliable, you need more sophisticated offline capabilities and data synchronization,” he explains. “Your microservices need to be more resilient to network partitions.”
Even technology choices shift. “Cloud-native solutions that assume unlimited bandwidth and perfect connectivity need adaptation,” he says. “You might use more edge caching, local data replication, or hybrid cloud approaches.”
The Database Challenge
One of the hardest parts of microservices, according to him, is data management. “The ‘database per service’ pattern sounds great in theory,” he says. “In practice, it’s complicated.”
The challenges start with existing data. “Most monoliths have deeply interconnected data models,” he explains. “Untangling those relationships while keeping the system running is like performing surgery on a moving patient.”
His approach involves gradual data separation. “Start by logically separating data within the same database,” he advises. “Use schemas or separate databases on the same server. Physical separation can come later.”
Transaction boundaries become a major consideration. “When your checkout process spans multiple services, you need to think about distributed transactions or eventual consistency,” he notes. “Most teams underestimate this complexity.”
The solution often involves rethinking business processes. “Sometimes you need to change how the business works to accommodate the architecture,” he admits. “That requires buy-in from stakeholders who understand the trade-offs.”
Monitoring and Observability
Distributed systems create new monitoring challenges that he learned to anticipate early.
“When everything was in one application, you had one log file,” he explains. “With microservices, you have logs scattered across dozens of services. Understanding what happened during a user transaction becomes detective work.”
His monitoring strategy focuses on business outcomes rather than just technical metrics. “You need to track user journeys across services,” he says. “Did the user successfully complete their purchase? Where did they drop off? These are the questions that matter.”
Distributed tracing becomes essential. “Tools like Jaeger help you follow a request as it flows through multiple services,” he explains. “Without tracing, debugging performance issues is nearly impossible.”
The operational overhead is significant. “You’re going from monitoring one application to monitoring 10 or 20 services,” he notes. “The tooling and processes need to scale with your architecture.”
Team Structure and Conway’s Law
One insight that comes up repeatedly in Ayodeji’s experience is how team structure affects system architecture.
“Conway’s Law is real,” he states. “Your architecture will mirror your communication patterns, whether you plan it or not.”
This reality affects how he approaches service boundaries. “If you have a team working on user management and another on billing, those naturally become separate services,” he explains. “Fighting this pattern usually leads to problems.”
But team structure needs to evolve with the architecture. “You can’t just reorganize the code without reorganizing the teams,” he notes. “Service ownership needs to be clear, or you end up with nobody taking responsibility for issues.”
The communication overhead increases significantly. “In a monolith, teams coordinate through shared code,” he explains. “With microservices, they coordinate through APIs and events. That’s more explicit but requires more discipline.”
When Microservices Go Wrong
Not every migration Ayodeji has seen has been successful. He’s candid about the failure modes.
“The biggest mistake is creating a distributed monolith,” he explains. “You break up the code into multiple services, but they’re still tightly coupled through database sharing or synchronous API calls.”
Over-engineering is another common problem. “Teams get excited about microservices and create too many services too quickly,” he notes. “You end up with services that are so small they have no business logic, just API calls to other services.”
Performance can actually get worse. “If you don’t think about data locality and network calls, microservices can be slower than the monolith,” he admits. “You’re trading in-process method calls for network requests.”
The operational burden often surprises teams. “Suddenly you need to deploy, monitor, and maintain 15 services instead of one application,” he explains. “Make sure your team has the operational maturity to handle that complexity.”
Success Patterns That Work And Looking Forward
“The most successful migrations have clear business drivers,” he explains. “Teams that migrate just because microservices are trendy usually struggle. Teams that migrate to solve specific problems, scaling bottlenecks, deployment issues, team autonomy tend to succeed.”
Starting small and iterating is crucial. “Extract one service, learn from the experience, then extract the next one,” he advises. “Each extraction teaches you something about your system and your team’s capabilities.”
Investing in tooling pays dividends. “Successful teams spend time building deployment pipelines, monitoring systems, and development tools before they extract services,” he notes. “The infrastructure work isn’t glamorous, but it’s essential.”
Ayodeji reflects on where microservices architecture is heading.
“The tooling is getting better,” he notes. “Service meshes, observability platforms, and deployment tools are making microservices more accessible to smaller teams.”
But he cautions against rushing into complexity. “Just because you can build a distributed system doesn’t mean you should,” he says. “Start with the simplest architecture that solves your current problems. You can always evolve it later.”
His advice for teams considering the migration is pragmatic: “Understand why you’re doing it, start small, invest in tooling, and be prepared for the operational overhead. Microservices aren’t a silver bullet, but they can be the right tool for the right problems.”
The key insight from his experience across different contexts and constraints is that successful architecture is about solving real problems, not following trends. “Good architecture serves the business and the team,” he concludes. “Everything else is just implementation details.”
WATCH TOP VIDEOS FROM NIGERIAN TRIBUNE TV
- Relationship Hangout: Public vs Private Proposals – Which Truly Wins in Love?
- “No” Is a Complete Sentence: Why You Should Stop Feeling Guilty
- Relationship Hangout: Friendship Talk 2025 – How to Be a Good Friend & Big Questions on Friendship
- Police Overpower Armed Robbers in Ibadan After Fierce Struggle


