Building a great product isn’t about getting it right the first time. It’s about breaking things, learning from the failures, and iterating until something exceptional emerges. At Lonti, we’ve spent the last ten years refining, rethinking, and rebuilding our low-code platform. It wasn’t always smooth sailing. We made mistakes. We pivoted. But ultimately, the lessons we learned shaped the platform we have today.
Looking back, no one remembers the broken prototypes, the pivots, or the false starts. They remember the final product—the one that actually works. Here’s how we got there.
The Early Days—Lessons from Failure
Back in 2014, we started our journey under the name Toro Cloud, believing that low-code could revolutionize enterprise integration. By 2016, we launched our first product, Toro Integrate—but there was a problem. It was a powerful tool, but it had no user interface. Developers had to configure everything through scripting and backend configurations, which slowed adoption.
We quickly realized that enterprise software needed more than just technical capability; it had to be usable. So, in 2018, we rolled out an Eclipse-based IDE to improve the experience. But that came with its own challenges—maintaining both a desktop and web version stretched our resources thin. On top of that, our name—Toro Integrate—gave the impression that we were only focused on integration, while we had already begun expanding into API development and automation.
These were painful lessons, but they taught us an important truth: great tech alone isn’t enough. It has to be intuitive, accessible, and clearly positioned.
The Pivotal Moment—Rebranding as Martini
By 2019, we knew we needed a fresh start. We rebranded our platform as Martini, with a sharper focus on low-code integration, API development, and workflow automation.
At first, it seemed like a breakthrough. Developers could build integrations visually, using low-code services—essentially drag-and-drop building blocks that handled API calls, automation, and data processing. But soon, feedback from our users revealed a major gap.
Developers needed more than just building blocks; they needed a way to orchestrate complex workflows. The original low-code service model was powerful but rigid. Some users loved it. Others found it limiting, especially when dealing with large-scale enterprise automation.
It became clear that while low-code could simplify development, it wasn’t just about making things easy. It had to support real enterprise complexity without creating new bottlenecks.
The Breakthrough—Workflows in Martini v2
By 2020, we had our answer. The next evolution of Martini introduced Workflows—a fully visual, drag-and-drop approach to managing integrations, automation, and data flows.
This shift was a game-changer. Now, instead of being locked into low-code services, developers could build full business processes visually, while still retaining the flexibility to write custom logic when needed. This made Martini more powerful, intuitive, and scalable.
For the first time, developers weren’t just using Martini to speed up API and integration development. They were building end-to-end enterprise solutions—without the constraints of traditional low-code platforms.
Reinventing the Business—From Martini to Lonti
By 2024, Martini had evolved far beyond its original purpose. It was no longer just an integration tool—it had become a full-fledged low-code automation and development platform. That realization led us to make one more bold move:
We rebranded as Lonti.
And we didn’t stop at just a name change. We fundamentally shifted our approach to how we delivered our platform. Instead of relying on traditional enterprise sales, we opened up Lonti to self-service access, letting developers explore and build without barriers.
Instead of trying to be a one-size-fits-all low-code platform, we embraced integration-first development, making it seamless for teams to connect their tools, automate processes, and build without limits.
This shift wasn’t just about branding—it was about aligning with how modern developers work. We knew that enterprise software shouldn’t feel like a locked-down black box. It should be adaptable, extensible, and developer-friendly.
What We Learned (And Why It Matters to You)
Looking back, every mistake, pivot, and delay was worth it. The biggest lessons?
First, listen to your users. Developers will tell you exactly what’s wrong with your product, if you’re willing to hear them out. The best features and improvements don’t come from boardroom strategy sessions—they come from real-world pain points.
Second, don’t rush to launch. Martini v1 was good, but v2 was great because we took the time to fix what wasn’t working. The extra time spent refining the platform made all the difference in building long-term trust with users.
Third, pivot boldly when needed. From Toro Integrate to Martini, from low-code services to workflows, from Martini to Lonti, every major pivot brought us closer to the product we always wanted to build.
Looking Ahead: We’re Just Getting Started
Lonti is the result of ten years of iteration, learning, and innovation. But the best products never stop evolving. While we’re incredibly proud of what we’ve built, we know there’s still more to do.
If you’ve ever been frustrated by low-code tools that feel too restrictive, Lonti is built for you. It’s low-code without limits—powerful, flexible, and designed for developers.
Top comments (0)