Why binding directly to APIs is the future—and how to make it work for you.
Let’s cut to the chase: if your frontend isn’t API-centric, you’re already behind.
We live in an API-first world. Frontend apps aren’t just pretty interfaces anymore—they’re dynamic front doors to complex systems. And if you’ve ever wrestled with manually wiring up data, tweaking UI logic across dozens of components, or rebuilding UIs every time a backend changes… you know the pain.
That’s where Bellini comes in. It’s Lonti’s API-first application builder that lets you design, bind, and deploy powerful frontends with minimal boilerplate—and maximum control. It’s low-code that doesn’t lock you in. Think: drag, drop, bind to APIs, customize what matters.
In this post, I’ll walk you through how I build API-centric frontend apps in Bellini—from project setup to deployment—using the tools and tricks I’ve learned along the way.
Before touching a component or styling anything, I start with one question: What APIs power this app?
In Bellini, APIs are the lifeblood. Whether they’re coming from Martini, built with Negroni, or sourced from third-party services, Bellini lets you plug in and bind UI components directly to live API endpoints. No need to write glue code or mess with endless fetch calls.
Best practice? Use Martini or Negroni to expose clean, consistent APIs before diving into the frontend. Trust me, this upfront investment saves you a ton of rework later.
Once your APIs are ready, it’s go time.
Bellini’s visual editor makes building the UI feel like playing with Lego—except every piece is backed by real data.
What’s magical here is the real-time feedback. Change a parameter, update your API, and Bellini shows you exactly how it flows through the app. No more guessing. No more refresh-compile-refresh cycles.
Here’s where Bellini really breaks the low-code stereotype.
You’re not locked into cookie-cutter components. You can bring in your own:
Bellini is low-code, not low-control.
So when you need to go beyond the basics—custom modals, advanced filtering, real-time updates—you’re covered.
Here’s a big one: error handling, loading states, and optimistic UI.
Bellini gives you built-in support to:
And yes, it’s all configurable. You’re not stuck with one-size-fits-none defaults.
Once your app is hooked up and running, Bellini makes it easy to preview, test, and publish.
Want to test an app with real data and share it internally? Done. Want to deploy it to production with a few clicks? Go for it. Bellini handles publishing, access control, and even versioning behind the scenes.
And if you’re using the Bellini Free Edition, you can publish up to 5 apps and share them with your team instantly—perfect for getting started.
I’ve used plenty of low-code tools. Most treat frontend as a form designer stapled to a spreadsheet.
Bellini is different.
It’s built for developers who want speed without sacrifice. You can move fast, build sophisticated apps, and still control every detail that matters—from logic to layout to APIs.
If you’re tired of writing the same boilerplate over and over—or battling rigid platforms that block you at every turn—Bellini might be the change you’ve been waiting for.
Bellini Free Edition includes:
➡ Start building API-first frontend apps now
Low code. No limits. Let’s go.