By Saba Gul
Today, we are proud to announce Elarian—a powerful new framework for building reactive customer-facing applications with dramatically less effort, resources, and time.
Why Elarian
We are the team behind Africa’s Talking . In building the communication APIs powering Africa’s digital ecosystem, we have been writing code and servicing developers across the continent for the last 10 years.
In this time, many great tools that improve the developer experience and productivity have come into the market, accelerating software development. Yet, when it comes to customer-centric software, developers still juggle significant, unnecessary complexity in designing and managing it.
The Problem
As the scale of your customer base and engagement goes up, the load of:
Maintaining customer profiles
Building and accessing databases and caches
State and event handling
all make the management of code complex, costly and time-consuming.
With Elarian, you scale the solution — not your time, cost, or infrastructure needs.
The Elarian Promise
While building Elarian, we had the needs and challenges of developers in mind—whether you are an individual operator, a small team of developers, or a business with a large user base.
At the heart of Elarian is our mission to radically enhance the experience and productivity for developers of every stripe—so they can build and test better, faster. This means shorter product development cycles and faster product innovation.
Elarian is a category-defining product in customer engagement. At its core, it is a customer data and automation framework, that gives developers a competitive advantage. Out of the box, it provides communications, payments, storage, reminders, and analytics infrastructure. This infrastructure is provided as a service, to interact with programmatically.
The Power of Elarian: 4 Core Offerings
Engagement Automation: Elarian is built for customer state and engagement management
Programmable Customer Objects: we define and manage the customer entity for you!
Code Against Customer Data: Elarian lets you issue simple customer commands, making it more efficient to write, reason about, maintain and organize code.
React Swiftly to Each Customer: Elarian is built to be highly reactive, without the implementation overhead.
Below, we discuss in more detail, with examples, the 4 most notable features of Elarian that make it a powerful framework that simplifies building and maintaining applications like the above.
Built for Customer State and Engagement Management
Building customer-centric software requires an effortless way to capture, track and react to customer engagement, events and state. We call this engagement automation.
This starts with defining a customer, which is central to Elarian. In our programming model, everything happens in the context of a customer. The customer forms the basic unit of abstraction, with programmable customer objects (more on this next), that allow for coding against a single customer, and building around their journey and state.
In our Event-Driven Model:
Engagement data is stored by the customer.
Each state handler is written from the perspective of a single customer.
A key-value store is provided for customer state.
Elarian creates a record of everything your application has done with a single customer. This allows you to readily access customer data and analyze customer engagement, without the overhead of designing and managing complex database deployments.
What This Allows You To Do:
Organize, track and merge customer states across channels.
Manage engagement-related and non-engagement-related customer state easily.
Access a readily-available cache of customer engagements, where you can read data from the customer’s perspective. These range from sending messages to handling payments to tracking customer activities.
Easily track and build your business logic around each customer’s profile, journey, and state. Initiate engagements through configured providers, and on each customer’s preferred channel. Your application code retains the same semantic whether sending an email or a chat.
Track individual customer events and interactions to understand the impact of each customer engagement and communication, if, for example, you are engaging customers on multiple channels such as email, SMS, and Whatsapp. This forms the basis of targeted engagement and contextual decision-making.
Programmable Customer Objects
Elarian SDKs offer a customer-centric programming model. You issue commands e.g. customer.addReminder(data) and are notified when data about your customer changes e.g. elarian.on('reminder', (data, customer) => {...})
Elarian’s customer objects give you powerful, programmatic access to customer data. Engagement data is sorted by customer, providing a unified customer view. This means event handlers will receive a customer object belonging to the customer that initiated the engagement.
Elarian provides a storage and runtime environment for each customer and carries the load of maintaining profiles, caches, state, and event-handling for each. In line with the customer being the unit of scale, all data that a customer generates is stored in the customer's perspective, making it easy for your application to build a better profile of the customer's behavior, without adding complexity to your code logic, database, infrastructure or analytics needs.
What This Allows You To Do:
Easy customer segmentation for targeted messaging, fragmented pricing, or personalization of customer experiences.
Event-handling and scheduling actions become extremely straightforward, without the need for additional infrastructure. The event handler receives a customer object belonging to the customer that initiated the engagement, or in case of scheduling, that the reminder was set on.
Customers can be reached on their preferred channel e.g. Grace wants her bank statements via WhatsApp, but Calvin prefers email.
Drive deep customer insights by adding a metadata layer on top to contextualize the customer segments even further, and surface more similarities between customers over time.
Code Against Customer Data
Elarian has SDKs that provide infrastructure, which means you interact only with Elarian. Coding against customer data makes it more efficient to write, reason about, maintain, and organize code. Most actions on Elarian are done from a customer's perspective.
Once you create a customer by initializing a new customer object, you can issue them simple commands, such as: getState, updateMetadata, updateAppData, addReminder, and sendMessage. With these commands at your disposal, you can abstract away communication protocols.
React To The Customer
Elarian sets up a persistent bi-directional link between your application and the Elarian server. A considerable advantage you gain from this is not needing to configure webhooks and HTTP servers.
We manage webhooks with the infrastructure providers and relay traffic via an event-driven model. This allows applications to react to engagement events or state changes over the persistent connection, making it possible to build highly reactive applications.
Case Study: Loaner App
Imagine you’re building a fintech app that provides loan facilities; let’s call it Loaner. To request loans, your customers interact with your app through a WhatsApp interface. In addition, your app needs to send highly targeted and personalized messages to encourage more engagement from customers. Building such an app at scale gets complex fast.
You need a system to allow customers to request loans, receive funds in their mobile wallets, pay back loans, and receive occasional reminders about their loans.
With Elarian, you can build a fully functioning app that does all of this, with about 260 lines of code, with no DBs, no queues, and no complicated logic.
Your application can also swiftly react to any data changes, via notifications generated when a customer’s data changes, e.g. when a customer sends you a payment or when a reminder fires. Some notifications include: onReminder, onReceivedWhatsapp, onReceivedPayment and onVoiceCall.
Let’s take the example of receiving an SMS from a customer. All you need to do is set an event listener as shown here:
Note that the customer parameter sent to the event handler represents the customer sending you an SMS. We describe this as using the customer as the unit of abstraction. This customer-centric pattern makes it easier to write complex logic.
Customer As The Stateful Actor
In Elarian, every customer object is an actor, with a corresponding state containing the records of everything your application has done with the customer. The customer you interact with is a virtual customer object (actor) inside Elarian. The customer state includes your most recent interactions with the customer as well as any other additional state your application would like to track.
Getting a customer’s state is then straightforward—see below.
Each customer triggers events by performing specific actions, and your application reacts by performing actions that may, in turn, result in more events. Thus, the primary stateful actor is the customer, and an optimal approach is to code against this customer (actor) as the main unit of abstraction.
Learn More
Check out the documentation for more examples and code samples.
If you have questions, comments, or need help with code, we would be delighted to help:
on Slack
on Twitter @ElarianHq
Sign up here to try out Elarian for yourself today—no strings attached. As they say, the proof is in the pudding itself!