Latest / The API Podcast with Fexingo: REST, GraphQL, and Modern Web APIs / API Composition The Hidden Engine Of Modern Tech
Transcript
- Lucas: Let’s talk about the hidden cost of your own architecture. If you’re building modern web apps in September twenty twenty-six, you probably have a dozen microservices talking to each other behind the firewall. But here’s the problem: your frontend developers are still writing code that stitches those services together on the client side. Luna: Right, so instead of one clean call, they’re firing off five requests just to render a dashboard. That sounds inefficient. Lucas: It is inefficient, and it’s expensive. We see teams spending forty percent of their engineering bandwidth just on data aggregation logic. Instead of pushing that work to the backend, they’re asking clients to do the heavy lifting. This is where API composition comes in. It’s not a new concept, but it’s the missing piece for most scaling startups right now. Luna: So you’re saying we should stop treating the API as just a database proxy and start treating it as a product layer? Lucas: Exactly. Think about how Shopify handles its storefront. They don’t let the browser fetch inventory, shipping rates, and product details separately. Their backend composes these results into a single, coherent response before it ever hits the network. The client sees simplicity; the server handles the mess. Luna: That makes sense. It shifts the complexity from the edge to the core, which is usually better equipped to handle retries and errors. Lucas: Precisely. And it saves money. Every unnecessary round-trip costs latency, which hurts conversion rates. When I look at the top performing e-commerce platforms today, they all use some form of Backend For Frontend, or BFF, to compose these responses. It’s an intentional design choice, not an accident. Luna: But doesn’t that create a bottleneck? If every request has to go through a composition layer, aren’t you just moving the choke point? Lucas: You’re moving the choke point from the unpredictable public internet to your controlled internal network. That’s a trade-off worth making. You gain observability, security, and consistency. Plus, you can optimize the composition layer independently of your frontend releases. Luna: I guess I haven’t thought about the release cycle benefit. Usually, we treat the API as static infrastructure, but if it’s composed dynamically, it becomes part of the feature rollout. Lucas: It absolutely does. Let’s take Stripe as another example. When they introduced Checkout, they weren’t just offering a payment button. They were composing tax calculation, fraud detection, and currency conversion into a single flow. Merchants didn’t have to build that logic themselves. The API did the work. Luna: That’s a powerful value proposition. You’re selling convenience by hiding complexity. But how do you manage versioning when the composition logic changes? Lucas: This is the tricky part. In a traditional REST setup, you version the resource. In composition, you version the interaction. So you might have v1 of the checkout flow and v2 of the checkout flow, even if the underlying payment service hasn’t changed. You need clear contracts between your composition layer and your consumers. Luna: So the contract is really about the business outcome, not just the data structure. That’s a subtle but important distinction. Lucas: Yes. And it requires closer collaboration between product and engineering. You can’t just throw endpoints over the wall anymore. You have to understand what the user is trying to achieve and compose the API to match that journey. Luna: It feels like we’re moving away from pure technical correctness toward experiential design. Is that safe for engineers who prefer clean abstractions? Lucas: It’s safer because it reduces fragility. When clients hold complex state and orchestration logic, they break easily. By centralizing that in the composition layer, you protect your ecosystem. You become the stable ground everyone builds on. Luna: I like that framing. Stable ground. Most of us just want our systems to stop crashing at three in the morning. Lucas: And composition helps with that. You can add caching, rate limiting, and fallbacks at the composition layer without touching the individual microservices. It’s a strategic buffer zone. Luna: So essentially, the composition layer is your first line of defense against system-wide failures? Lucas: It is. And it allows you to degrade gracefully. If one service is slow, the composition layer can return partial data or a cached version instead of failing the whole request. That resilience is invisible to the user but critical for retention. Luna: That’s the kind of thing users notice only when it’s gone. Having it there quietly is a huge win. Lucas: Agreed. Now, I want to pause here for a quick note on support. If today’s conversation gave you something usable for your team, consider buying me a coffee at buy me a coffee dot com slash fexingo. It keeps the research sharp and the ads out. Luna: Yeah, supporting independent tech analysis helps us keep digging into these patterns rather than chasing trends. Lucas: Thanks for that. Back to the architecture. Let’s talk about the tooling landscape. There are dedicated GraphQL servers like Apollo, but also generic gateways like Kong or Apigee that can handle composition. Luna: Which one do you recommend for a mid-sized company trying to make this shift? Lucas: If you’re already invested in GraphQL, stick with the native ecosystem. It’s built for composition. If you’re rest heavy, a gateway approach might be less disruptive. Don’t force a paradigm shift just for the sake of it. Solve the immediate pain point first. Luna: Pragmatic advice. Start where the friction is highest and work outward. Lucas: Exactly. Look at your analytics. Find the pages with the most network calls. Optimize those first. You’ll see ROI immediately. Luna: That’s a concrete starting point. Most teams would kill for a metric like that. Lucas: It’s there if you know where to look. Network waterfall charts tell the whole story. Luna: So, is API composition the future standard, or will microservices eventually become smart enough to talk directly to each other? Lucas: Microservices will always need an orchestrator. Whether it’s a human, a workflow engine, or an API composition layer, someone needs to tie the threads together. The trend is toward intelligent, automated composition, but the principle remains. Luna: Automation is key. Manual stitching doesn’t scale. Lucas: Correct. As your product grows, manual integration becomes a liability. Automated composition lets you scale features without scaling chaos. Luna: It’s interesting how the burden of complexity shifts back and forth depending on where you put the intelligence. Lucas: It always shifts. Our job as architects is to move it to where it can be managed best. Usually, that’s the backend. Luna: Well said. Shifting complexity to the center to save the edges. Lucas: Right. It’s about protecting the consumer experience by absorbing the cost internally. Luna: Do you think smaller teams can afford this complexity? Or is it only for big tech? Lucas: Open-source tools have made this accessible to everyone. You don’t need enterprise licenses to compose APIs anymore. The barrier is mostly mental. Are you willing to rethink your endpoint strategy? Luna: Mental shift. That’s often harder than the technical implementation. Lucas: Always. Once you make the shift, though, the efficiency gains are immediate. Your load times drop, your error rates stabilize, and your team spends less time debugging network issues. Luna: Those are the metrics that matter to leadership. Faster, steadier, cheaper. Lucas: Exactly. It’s a business decision disguised as an engineering pattern. And that’s why it works. Luna: A business decision. I’ll remember that the next time I’m designing an endpoint. Lucas: Just remember: the simplest interface for the user is often the most complex system in the backend. Embrace that complexity. Compose it well. Luna: Here’s to simpler screens and smarter servers. Thanks for the perspective, Lucas.