is now
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.
Step 1: Think in APIs First
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.
Step 2: Drag, Drop, and Bind (Seriously)
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.
- Drag a component (say, a data table or form field) into your canvas.
- Bind it directly to an API response, parameter, or mutation.
- Set up dynamic expressions or conditional logic with a few clicks.
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.
Step 3: Customize Where It Counts
Here’s where Bellini really breaks the low-code stereotype.
You’re not locked into cookie-cutter components. You can bring in your own:
- Custom JavaScript functions for calculated fields, dynamic behavior, or business logic.
- External libraries (like Chart.js, Moment.js, or whatever suits your stack).
- CSS overrides and custom components for full control over the look and feel.
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.
Step 4: Handle API States Like a Pro
Here’s a big one: error handling, loading states, and optimistic UI.
Bellini gives you built-in support to:
- Show loaders while API calls are in flight.
- Display error messages with detailed API feedback.
- Handle form submissions, mutations, and rollbacks gracefully.
And yes, it’s all configurable. You’re not stuck with one-size-fits-none defaults.
Step 5: Test and Deploy—Fast
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.
Final Thoughts: This Is What Low Code Should Be
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.
Want to Try It?
Bellini Free Edition includes:
- Create 25 apps
- Publish 10 apps
- Web apps only
- 5 authenticated users
- Community support
➡ Start building API-first frontend apps now
Low code. No limits. Let’s go.
