Event-Driven Architecture Made Easy

Users expect intelligent, responsive, and always-available digital experiences. Business leaders expect real-time insights. Batch processing, monoliths, and tightly-coupled RPC-based systems just don't cut it anymore.

What is Event-Driven Architecture?​

Modern event streaming platforms such as Apache Kafka, AWS Kinesis, and Apache Pulsar have enabled the emergence of event-driven architecture (EDA). In EDA, different system components communicate by producing and consuming events, allowing for loosely coupled but nearly-instantaneous interactions.

Legacy applications, whether monolithic or microservice-based, rely on direct RPC calls for synchronous communication between services and utilize batch processing (often a scheduled cronjob reading a database table) for asynchronous processing. This approach yields several issues:

• Reliability: synchronous RPC calls are susceptible to cascading failures when an upstream service is temporarily malfunctioning.
• Tight Coupling: changing the API contract or behavior of one service can break all other systems. This complexity slows development velocity.
• Data Liberation: it is challenging to perform analytics on the events happening in a system architec this way. This manifests itself in stale data presented to users and business stakeholders.

By using a streaming platform for inter-service communication, you can solve all of the above problems.

If you properly implement retries and dead-letter queues, your system will patiently tolerate intermittent outages rather than suffer from cascading failures.

Using events rather than batch processes for asynchronous processing allows producers to write an event only once, still allowing it to be consumed multiple times (eg. an order-placed event is consumed by the shipping service, the payment service, and an analytics process). The producer doesn't need to worry about who consumes the event (or when), and we get the added benefit of near-instantaneous performance.

Event-Driven Apps are Hard​

While event-driven architecture is a drastic improvement over point-to-point RPC calls or batch processing, it can quickly pose problems of its own.

With no central oversight, your event-driven systems will start to look like a pile of spaghetti:

The fully decentralized nature of most event-driven systems causes headaches with debugging and managing complex multi-step processes. Small changes to business logic can require changing multiple microservices.

But they Don't Have to Be​

By building with LittleHorse, you can enjoy all of the benefits of event-driven applications without the chaos of uncoordinated services. LittleHorse delivers the oversight and orchestration you need for proper governance.

LitleHorse allows you to model event-driven processes as workflows. Each workflow triggers tasks that are loosely linked together and overseen by the LittleHorse Kernel. Tasks are reusable (and often pre-existing) pieces of code that perform specific business functions.

LittleHorse makes your systems robust to failure and gives you full control to debug any issues. If a modification to the overall business process is needed, there’s only one place to make the change.

LittleHorse gives you a platform to more easily develop event-driven applications. LittleHorse tracks everything that is happening and will happen in your business workflows. Work with LittleHorse today to automate your business processes, integrate real-time data into daily operations and act on business events with immediate and intelligent actions.

Get Started​

Get started today with our quickstarts