8x faster: A huge win for Lumanu’s development velocity with Hasura

Optimized from 15+ microservices to a single GraphQL API built around Hasura
8x speed up in development velocity – features that took months are now ready in days
10-15x latency boost – an app latency of seconds shaved down to milliseconds

In 2017, the “creator economy” was in its infancy and Lumanu was in the right place, with the right idea, at the right time. Today, Lumanu is a key player in a hot influencer marketing sector and adjacent verticals like event marketing and creative productions. Billions of dollars are flowing from brands into the hands of the creators, freelancers, and their managers/agents on a variety of projects from Coachella photoshoots to sponsored YouTube videos.

Lumanu acts as a master vendor for all of a firm’s contractors and suppliers – making payments, handling onboarding, compliance, and more. Lumanu’s platform is built with Hasura as the engine that powers it all.

Creators and freelancers who sign up for Lumanu can get paid by any buyer in the Lumanu network, and buyers use Lumanu to streamline the operation of making timely and compliant payments to their stables of creators and freelancers.

Bogged down by microservices and seeking radical change

Originally, Lumanu was built on a Clojure-based microservices architecture that proved too rigid for their needs. Releasing new features took too long. As a startup, they needed to be able to experiment quickly and cheaply, so that even when experiments failed, it didn't affect them tremendously.

Lumanu’s VP of Engineering, Chris Smith, initiated a re-platforming initiative to boost their development velocity, and the team evaluated a few approaches. But the improvements were incremental and not the radical unlock that Smith envisioned.

Then the Lumanu team tested Hasura, a tool that Smith was familiar with from a previous job. After a successful spike, in the summer of 2023, they did a full rewrite of their product code, using Hasura to bring everything together.

“We rebuilt everything around Hasura. It's the centerpiece.” – Chris Smith, VP of Engineering

Improving development velocity by 8x with Hasura

“There were too many layers between the product team and the engineers, and ultimately the data,” Smith said about Lumanu’s older platform. Before Hasura, feature development cycles were long. Product designers would mock up UI concepts based on customer needs, which would then pass through several layers: a backend engineer designing the data schema, another engineer creating a domain API (or evolving an existing one), and finally the GraphQL engineer adapting a GraphQL API to fit the service.

“Then they figure out, ‘Oh, wait, it doesn't do what we need.’ Now we have to go all the way back through,” Smith said of the tedious nature of development pre-Hasura.

Hasura allowed the Lumanu team to compress development and feedback cycles immensely. Smith continues, “We took about two months to develop a new feature set before Hasura, and now, it takes us maybe a week for that same thing.” That’s an eightfold increase in mean time to deployment, the kind of multiplier impact that Smith wanted from the new platform.

“Before Hasura, it took us about two months to ship a feature set. And now we estimate it would take us a week for the same thing.” – Chris Smith, VP of Engineering

As Smith reiterated, Hasura is not just a GraphQL API – Hasura is the framework for responding to changes in the data domain. Now, keeping the API in sync with domain changes has become a breeze.

Before using Hasura

After using Hasura

“[Hasura] lets you tap into the strength of the database rather than treating it as a ‘dumb’ data store,” Chris said.

“And the domain becomes the interface for the application. You can make a change to a table, an event fires, another thing happens, the API sees it.”

Empowering teams with self-serve composability and API standardization

Besides faster product velocity, out-of-the-box API standardization and composability with Hasura have been another huge win for the Lumanu team. Smith recalls an example: “One of our designers asked if a column on a table that we were displaying could be sortable. And the engineers couldn’t enable it because of the effort needed to build that into the API.”

Hasura has removed these challenges. “All the APIs for all the tables look the same – they all act the same, they all have the same capabilities. That's been really key for the team consuming the API.”

Smith also likes that APIs can be customized as needed. “We don't customize a whole lot, but it’s been nice to have the option.” His team also uses Hasura Actions when it doesn't make sense to talk to a database, or when they need to talk to some other system. For example, they used this to integrate Notion API into their GraphQL API. “That was pretty seamless,” Smith said of the experience.

Composability of the Hasura API was another powerful draw for Lumanu. Before Hasura, most of their APIs were very flat. Smith added, “The relationship aspect is a huge win as well,” and the ability to add a relationship on the data side and have that instantly available in the GraphQL API is yet another example of Hasura eliminating an entire development cycle. Smith praised the benefits of self-serve composability in the Hasura API. “Our frontend team appreciates that they can just manage that themselves.”

From seconds to milliseconds – a huge win in speed

A 10x latency improvement was a surprising and delightful side-benefit of moving to Hasura. Previously, the Lumanu app’s P95 latency was 2.5 seconds for most API calls. Now it’s averaging 150 milliseconds, Smith said.

“With Hasura, P95 latency improved from 2.5s to 150ms – a 15x speed improvement.”

When migrating to Hasura, the team had not set explicit targets for speed, other than “not worse.” And the team has blown that goal away by an order of magnitude.

“It's been a huge win,” Smith said. “I can't say it any other way.”