Author picture Phil Leggetter

What is an Event Gateway?

Published

Article image

Whatever you're building, there's a good chance that at least some part of it is event-driven. Whether you're integrating with one or two external APIs or orchestrating a full microservices architecture, you need to efficiently ingest, process, act on, and deliver events.

Typically, this involves chaining together several standalone tools. However, multiple moving parts can introduce fragility. Rather than relying on your tooling to manage your events, you can end up managing your custom event-driven architecture infrastructure and multiple integration points.

What you need is a single platform that can manage your event lifecycle, support your full software development lifecycle (SDLC) from end to end, and provide simple but powerful integration to internal and external services. And that is the event gateway.

What does an event gateway do?

An event gateway is a platform that sits at the heart of your event-driven architecture. Think of it as a mix of air traffic control and a logistics network for your events. It ingests events, filters and transforms them, and then sends them on to where they're needed.

But here's what sets the event gateway apart from alternative approaches. The event gateway is an all-in-one tool that handles:

  • Receiving events: Ingesting events from a source shouldn't require extensive integration work. Instead, you should be able to consume events using light-touch, standards-based methods like webhooks.
  • Delivering events: Similarly, getting your events to their destination should be easy to set up without the need for complex integrations.
  • Filtering events: Process only those events that meet the metadata and payload criteria you've set.
  • Transforming events: Transform events to be compatible with destination systems.
  • Retries and rerouting: When a destination is temporarily unavailable, retry event delivery automatically so you don't have to build that logic into your application.
  • Scaling to meet demand: Automatically adjust to the ebb and flow of demand.
  • Security and compliance: Authenticate and authorize sources and destinations.
  • Operational visibility: Provide end-to-end insights into what's happening at the system level and the individual event level.

Now we've had a high-level overview of what an event gateway is, when would you use one?

When to use an event gateway

Let's get into some of the ways you can put an event gateway to work.

  • Inbound webhook infrastructure: Managing a few webhooks is simple. But as you add more, you need to start thinking about queuing, routing, and retry mechanisms to give you the certainty you need to rely on them. An event gateway ensures you can ingest and act on inbound webhooks without setting up custom infrastructure.
  • Outbound webhook infrastructure: Enabling your customers to subscribe to events and receive them via outbound webhooks can be complicated. Rather than building the infrastructure to scale, handle retries, and give you visibility, an event gateway lets you focus on solving end-user problems.
  • Asynchronous API gateway: Ingesting events securely from devices, SDKs, and other types of clients is a significant scalability challenge. By decoupling the system ingesting the API requests and the service doing the asynchronous work, an event gateway ultimately works very differently from an API gateway while providing similar observability and logging benefits.
  • Connecting third-party services: When independent systems need to communicate, an event gateway provides a reliable intermediary that can transform and filter payloads, route events, and enable the integration of multiple third-party systems.
  • Messaging queue for serverless applications: In serverless architectures, an event gateway acts as the central hub for all asynchronous communications between the applications and services within your event-driven application. It enables you to add reliable, at-least-once delivery of messages between serverless functions and third-party services.

How does an event gateway work?

You can think of an event gateway as similar to an API gateway, but tailored to ingest requests at scale and manage the flow of events rather than just API requests. It does not return the response to the request originator synchronously like an API gateway. An event gateway serves as a centralized platform that orchestrates the operational aspects of event handling, uniting selective functionality often found across API gateways, queues, message brokers, etc., under one system.

One aspect of the event gateways, at present, is they tend to focus on HTTP I/O because HTTP is ubiquitous: events are ingested and delivered via HTTP. This makes it compatible with as many event sources and destinations as possible, often without the need for custom development. However, as event gateways evolve, we expect to see support for more transports, event protocols, and formats.

What tools does an event gateway replace?

You might be thinking that we already have the tools to do these jobs. However, an event gateway brings them all under one umbrella so you can reduce development effort and operational complexity and increase developer productivity.

With an event gateway, you have the opportunity to replace:

  • API gateways and other integrations to ingest and deliver events: Whether setting up a separate API gateway to process inbound webhooks or writing custom code to interface directly.
  • Message queues: Queuing events for reliable deliverability and failure management, with filtering according to payload and metadata.
  • Message routers: Routing events based on rules defined around the event metadata and payload.
  • Complex processing tools: Enriching and transforming events is not often supported by message brokers, meaning you need to route events out into separate tools.
  • Custom code to enable retries: Implementing reliable message delivery often means writing your code to keep track of the delivery status, managing dead letter queues (DLQ), and then retrying in the event of a failure.
  • Observability tools: You'll often need one or more external tools to track and understand event flows. That complicates both your architecture and your workflows.

Getting started with an event gateway

Hookdeck is an event gateway we created to make building reliable, secure, event-driven application architectures easier. If you want to dive deeper into how we came to define the event gateway product category, read our introduction to event gateways.

As discussed, you can combine other technologies to create an event gateway. For example, AWS API Gateway + Amazon EventBridge or Azure Event Grid + Azure Functions. Read the event gateway comparison guide for a full side-by-side comparison of event gateways.




Try Hookdeck for free or share your EDA requirements and book a demo

The Hookdeck Event Gateway