Blog / Insights

The First Step to Organic Software

We're building organic software that wraps around the way a business actually works: it adapts to changes, learns from mistakes, and heals itself when something underneath moves. Apps are the first major step to making truly adaptable software.

Shifting deployment times from weeks to hours

For most software companies the time between a customer describing a problem and something being done about it is often weeks, usually because new features to the core products undergo strict review and design. We introduce apps as a solution to expedite niche feature development for individual customers. It's a second home for Light product code that's deliberately separate from the core platform and released on its own fast pace, where something built for one company can go live without waiting and with fewer blockers often on the same day.

This effect has been felt more widely than we expected: the repository is 8 weeks old and already holds over 100 apps, most of them built to answer a question a single customer asked. For example, KeyShot wanted to start its reconciliations from a clean opening balance rather than tracing every account back through 2 closed years. So we built an app for them and deployed it on the same day.

In just 8 weeks we've built over 100 custom apps, for problems that would usually sit in the backlog of our main product.

Diagram of two paths a customer question can take. The first path, unchanged, runs from the question through the roadmap and a core release to every customer, and takes weeks. The second path, new, runs from the same question through an app to the single customer who asked, and lands the same day.
We now adopt two methods to delivering features, on two different timescales.

Harnessing agents to build high quality apps

Apps are fully built by agents and this is what makes that pace possible. The interesting problem that emerges is drift and as apps grow the key problems shift from output to consistency, maintenance, and design. So we make sure agents adopt Light's own principles rather than inventing their own. Components are taken from the product's source and the palette is defined through rules and definitions. We tested a number of solutions to design consistency including a compiler adopting a frontend-as-code methodology, shared components library, and exported components from our core product frontend. Whilst the custom compiler added good consistency and readability to the code, the exported components library was able to cut drift and maintenance with little engineering overhead. As a result, agents are able to safely and effectively build apps that both satisfy the needs of the customers, and fit our unique Light design language, integrated seamlessly into Light's native product.

Organic software for our customers

What this adds up to, from a customer's side, is a product that grows into the shape of their business and integrations. Customers run Light alongside their own systems, and each of those connections is just another app built on the same core and so as a result our integration surface grows with the customer base. We also enable self-healing through a custom automated coding agent that runs cron jobs to check the core product's public API against every app each day, so that when it's updated we can find it and fix it before the customer notices. Apps give large customisability in features and opportunity and the breadth that apps provide gives a compounding effect such that any one niche problem raised by one customer is likely solved already by an app. This now means Light can provide adaptive software for every customer quickly, building towards our larger vision of organic software.

Apps run inside Light, the agentic accounting platform. See what Light already connects to in the App Store, or book a demo.

Similar articles

Ready to build what's next?

Bring your ideas to life with Light. Explore what we can create together.

Book a demo