In an exclusive interview with VMblog, Matt DeBergalis, Chief Technology Officer and Co-Founder of Apollo GraphQL, shares critical insights on how GraphQL is revolutionizing API orchestration for enterprises facing growing integration challenges.
As organizations routinely work with 25-50 or more APIs, DeBergalis explains how Apollo’s declarative, graph-based approach eliminates the complex, error-prone orchestration code that delays releases and increases technical debt. With Gartner predicting over 60% of enterprises will use GraphQL in production by 2027, DeBergalis makes a compelling case for why this transformative technology allows developers to focus on business requirements rather than integration details�delivering better software faster while significantly reducing development and maintenance costs.
This Q&A explores how Apollo’s technology is helping companies create unified data models that bring together REST APIs, GraphQL services, and third-party systems into cohesive customer experiences.
++
VMblog: What is the API orchestration problem and how does GraphQL help solve it?
Matt DeBergalis: Software is built on APIs – lots of them. A big part of software development is simply writing the code to call these APIs, convert data to the right format, handle errors, and sequence operations correctly. This orchestration work is often slow, error-prone, and can represent a significant fraction of total development costs. As applications now routinely integrate with 25-50 APIs or more, this orchestration complexity delays releases and drives up technical debt.
At Apollo, we’re solving this by orchestrating APIs declaratively with GraphQL, replacing bespoke orchestration code with battle-tested, standards-based infrastructure. Think of it like SQL for databases or React for user interfaces or Kubernetes for containers where you declare intent and the system handles execution. Like these other declarative architectures, GraphQL makes it possible to build complex applications much more quickly and with less risk.
By 2027, Gartner predicts more than 60% of enterprises will use GraphQL in production. The industry is clearly shifting toward declarative, platform-oriented approaches, and graph-based API orchestration has emerged as the way forward.
This transformation means developers focus on business requirements instead of wrestling with integration details – delivering better software faster with significantly reduced development and maintenance costs.
VMblog: How does declarative architecture change API development compared to traditional methods?
DeBergalis: GraphQL isn’t about replacing existing APIs or the tools used to build and manage them. With cloud-native architecture, microservices, SaaS and other forces driving API adoption, orchestration becomes a necessary part of a complete API strategy. GraphQL complements existing API technologies like REST and existing API infrastructure.
What changes is how those APIs are assembled together into applications. Declarative architecture transforms API development by separating “what” from “how.” Traditional approaches require procedural code that explicitly defines each step – when to call APIs, transform data, and handle errors. It’s tedious and error-prone. Our declarative approach at Apollo lets you define your data model as a graph, map APIs to that model, and write queries expressing intent while the infrastructure handles execution details.
Moving to a standards-based, declarative model for API orchestration, developers can treat APIs as truly composable building blocks and focus on creating great experiences rather than writing boilerplate code for data fetching and transformation. The benefits are dramatic: development time shrinks, you get automatic performance optimizations like parallel execution, and maintenance becomes simpler. We’ve seen this pattern revolutionize other areas – Kubernetes for infrastructure, React for UI – and APIs are the last holdout.
VMblog: Why is industry-wide GraphQL adoption becoming a survival imperative for companies facing integration challenges?
DeBergalis: Organizations clinging to traditional Backend-For-Frontend architectures face an existential threat. When backend systems evolve, these fragile approaches create technical debt that paralyzes innovation cycles. At Apollo, we’re seeing graph-based API orchestration emerge as the solution. It creates a unified abstraction layer that centralizes API connections, eliminates code redundancy, and adapts to schema changes without rewrites. The query optimization dramatically reduces API calls through intelligent batching.
In today’s market, businesses that win are those that can move fast and meet customers where they are with exceptional experiences. This comes down to your ability to efficiently assemble your APIs into high-quality, cohesive customer journeys – whether in retail, finance, healthcare, or any other industry. When your competition can deliver new features in days that would take you months, you’ve already lost.
For enterprises integrating dozens of systems, the choice is stark: adopt orchestration or watch more agile competitors deliver superior experiences while development teams waste resources rebuilding broken integrations. This isn’t just about technology – it’s about maintaining your competitive edge. Companies that centralize their API strategy around a graph can innovate faster, deliver better experiences, and adapt to market changes while others struggle with integration bottlenecks.
VMblog: How do Apollo connectors allow GraphQL, REST APIs, and other API types to all work together?
DeBergalis: Our Apollo Connectors create a unification layer for your API ecosystem. When you define your graph, you’re building a single coherent view of your data, and Connectors map your APIs onto that model. This means REST APIs, existing GraphQL services, and the real-world entities like inventory, payments, and third-party APIs all contribute to a unified graph. I often demonstrate this with flight data – completely different APIs from FlightRadar24 and the FAA appear as a single cohesive model, with the system automatically routing queries to appropriate backends.
This approach eliminates the painful aspects of API orchestration: protocol conversion, authentication juggling, and format translation. Teams can continue using whatever API technologies make sense for their services, while consumers get a clean, consistent interface. This addresses the hidden cost that most API strategies miss – the massive investment required to make disparate APIs work together coherently.
The business impact is profound. Organizations can evolve their architecture incrementally without disruptive rewrites, bringing legacy systems into modern architectures without replacing them. New customer experiences can be assembled in days rather than months. When market opportunities arise, you can quickly combine existing capabilities in new ways without rebuilding backend services.
This flexibility creates a foundation for continuous innovation without the traditional friction of API integration – ultimately giving you both the agility to move quickly and the stability to build on what already works.
VMblog: How does the Model Context Protocol (MCP) relate to API infrastructure for AI systems?
DeBergalis: While MCP standardizes communication between language models and tools, it’s only part of the solution for AI systems accessing data. MCP needs to work alongside a secure orchestration layer between AI agents and the services they access. This layer serves as critical infrastructure that enforces security policies, handles authentication, manages rate limits, and decouples AI system development from existing services.
MCP functions as the protocol between AI and this orchestration layer, but it’s the layer itself that translates MCP into appropriate API calls to existing systems. This is where a graph-based approach becomes particularly powerful. The declarative nature of a graph allows AI systems to interact with data in terms of concepts and relationships rather than endpoints and formats.
This approach prevents organizations from having to rebuild their entire API ecosystem while maintaining security and governance. It also accelerates AI development by providing a consistent, semantically rich interface to enterprise data, regardless of where that data actually lives.
As AI systems increasingly access sensitive, real-time data, this orchestration layer becomes essential for enabling safe, controlled interactions with enterprise systems – ultimately determining how quickly organizations can safely deploy AI capabilities that deliver real business value.
##
