---
title: "Accelerating Developer Productivity with Federated Gateways"
description: "Learn how federated gateways from Zuplo allow teams to control their own gateways, enabling faster, independent releases."
canonicalUrl: "https://zuplo.com/learning-center/accelerating-developer-productivity-with-federated-gateways"
pageType: "learning-center"
authors: "josh"
tags: "API Gateway"
image: "https://zuplo.com/og?text=Accelerating%20Developer%20Productivity%20with%20Federated%20Gateways"
---
Velocity matters. Product release cycles are now exceptionally fast. Companies
ship fixes and minor updates daily and major features weekly.

The catalyst for this is developer productivity. If you can get your dev teams
working together and efficiently, they can blitz through backlog and customer
requests like it’s nobody’s business.

This makes it all the more frustrating that API teams have been left out of this
blitzing. API developers have been left behind in terms of a better developer
experience. This makes them look bad.

![API Productivity](/media/posts/2024-05-24-accelerating-developer-productivity-with-federated-gateways/image2.png)

At Zuplo, we’re all about the API developer experience. We want to make API
developers fast, and federated gateways will do precisely that.

## Ship Fast, Earn More Money

You are only as fast as your slowest release cycle.

Let’s say you have two dev teams, A and B:

- Team A works on the `/product` endpoints. They are constantly working to get
  new features out to users.
- Team B works on the `/billing` endpoint. They also want to send updates but
  must be more cautious–a bad deployment can be mission-critical.

What happens if both `/product` and `/billing` are behind the same API gateway?

Your deployment cycles look like this:

![Deployment Cycles](/media/posts/2024-05-24-accelerating-developer-productivity-with-federated-gateways/image1.png)

Team A is building but is always waiting for Team B to deploy. Team B needs to
test their deployments extensively to avoid breaking anything, while Team A
better not screw up the config and bring down the whole API, and bring down the
wrath of Team B while they are at it. Only once everyone is good to go can
everything be pushed through.

In large organizations with a monolithic gateway, release trains rule with
everyone on the same schedule. Let’s say changes are pushed to either staging or
production every other Tuesday. OK, so you have a new feature and push it to
staging.

In the best possible world, you still have to wait two weeks for it to be
deployed to production. In the real world, you have to rework the code based on
feedback, errors, changes, etc., so you might miss that release window. Now you
are waiting a month. That’s how you get a release train that suddenly turns into
a two-month release cycle.

Then, you've also got to deal with environment-specific configurations, naming
conventions, and conditional statements. Every team has to do this, and every
team has to coordinate with every other team. This is what slows API deployments
down.

This inertia matters.

If you can't release features, you're losing money. Every hour, day, or week of
deployment delay adds to a massive handicap. You're an hour, day, or week behind
on knowing if a new feature is working. Then, the update to that feature takes
more time to deploy. It's a vicious cycle of slowness and frustration.

This only gets worse as you scale. More teams mean more waiting for the slowest
group, and more processes are involved to get everyone on the same train.

So, what if Team A could deploy on their own? They could cut this time down from
weeks to days. Updates could be shipped in hours. That's the kind of speed that
is genuinely required for shipping and growing API-first products.

How can we then do this? Using Zuplo with our federated gateways.

## Ship Faster With Federated Gateways

With federated gateways, each team gets control of its own gateway, which feeds
into the main gateway. No more waiting around for slowpokes or worrying about
someone else breaking your code. Each gateway can be deployed, rolled back, and
managed fully independently of the others with no impact on the others.

Now, each team can have their own train.

![Team Independence](/media/posts/2024-05-24-accelerating-developer-productivity-with-federated-gateways/image3.png)

Team A can be on the express, blasting out features, while Team B takes the
local, carefully testing and QAing their builds for a month without getting
death stares from Team A.

And when Team C comes along and wants to add `/analytics`, they can mess with
whatever they want without Teams A and B losing their minds.

![Independent Teams](/media/posts/2024-05-24-accelerating-developer-productivity-with-federated-gateways/image4.png)

Now, each team can be productive at the pace required for their part of the API,
leading to a better developer experience. Each team can work on their endpoints
without constantly looking over their shoulder, worried that other teams are
going to screw everything up. Teams can also use their authentication schemes,
rate limits, and other policies without affecting other teams, with no more
lowest-common-denominator API policies.

Onboarding new developers is easier. They only need to worry about their own
gateway, not the whole monolith. Debugging and troubleshooting become much
simpler when each team has its own isolated environment. Rolling out new
versions and doing A/B testing is a snap when each team can control its own
gateway. Experimentation becomes the norm, not the exception.

With clear ownership and autonomy, teams are more invested in the success of
their APIs. They can innovate without roadblocks and unlock more value for the
company:

- **Faster time-to-market for new features and products.** When teams can move
  at their own pace, the company can respond to market demands and opportunities
  more quickly.
- **Increased experimentation and innovation.** With the freedom to try new
  things without affecting other teams, developers can develop creative
  solutions that drive the business forward.
- **Improved quality and reliability.** When each team is responsible for its
  own gateway, they have a vested interest in making sure it's rock-solid. This
  leads to better overall API quality and fewer disruptions for customers.
- **More efficient use of resources.** Teams can focus on their core
  competencies without getting bogged down in coordination overhead. This means
  the company can get more done with the same headcount.
- **Better alignment with business objectives.** Federated gateways allow for
  more granular control and monitoring of APIs. The company can make data-driven
  decisions and optimize APIs to meet specific business goals.
- **Faster response to customer needs.** With each team in control of their own
  destiny, they can quickly adapt to customer feedback and changing
  requirements. This agility is critical to staying competitive in today's
  fast-paced market.

## Unleash Your API's Potential with Federated Gateways

The API developer experience has been neglected for far too long. While the rest
of the software development world has been speeding ahead, API teams have been
stuck in the slow lane, bogged down by monolithic gateways and cumbersome
deployment processes.

But it doesn't have to be this way. At Zuplo, we believe that API developers
deserve better. That's why we've built a platform that puts the API developer
experience front and center, and federated gateways are a key part of that
vision.

With federated gateways, you can:

- Boost developer productivity by giving each team control over its own gateway
- Increase team autonomy and ownership, leading to more innovation and better
  quality
- Accelerate shipping velocity by eliminating bottlenecks and enabling parallel
  development
- Unlock more value for your company by aligning APIs with business objectives
  and responding faster to customer needs

In short, federated gateways are a game-changer for API development. They allow
you to break free from the constraints of monolithic architectures and unleash
the full potential of your API teams.

The best part? More productivity and faster shipping mean more money for your
business. It's a win-win situation.

So, if you're ready to take your API development to the next level, we're here
to help. [Reach out to us](https://zuplo.com/meeting?utm_source=blog) to discuss
how we can set up federated gateways in your organization.