How Large Can a Leo App Get?
You can keep adding modules, users, and data — and keep it stable — because it's a real Rails + PostgreSQL app.
This is one of the most important questions to ask before you invest months building a platform for your organization — so it's worth answering clearly.
Short answer: you can go very large. Leo isn't building a toy or a locked-in "no-code" gadget. It's writing a real Ruby on Rails application backed by a real PostgreSQL database — the exact same battle-tested technology stack that runs some of the biggest software companies in the world. You can keep adding modules, features, users, and data, and the system will handle it.
Why this stack scales
Ruby on Rails and PostgreSQL are not new or experimental. They've been refined for nearly two decades and power applications serving billions of requests:
- Shopify — runs millions of stores on Rails and handles enormous traffic spikes (think Black Friday) on the same framework your app uses.
- GitHub — the home of over 100 million developers and their code, built on Rails.
- Airbnb — grew from a small Rails app into a global platform.
- Stripe — processes a huge share of the internet's online payments with Ruby at its core.
These companies didn't outgrow the framework — they scaled on it. The point is simple: the foundation under your app is the same one trusted by giants. It is designed to grow with you, not to cap you at a certain size.
About your data: PostgreSQL is one of the most reliable, mature databases in existence. It comfortably stores tens of millions of records, handles complex relationships between your modules, and keeps your data safe and consistent. Storing more data as your organization grows is exactly what it's built for.
A bigger app means more moving parts
There's an honest caveat that applies to every serious software system, no matter who or what builds it: as you add more modules and features, the application gets more complex. More parts means more things that interact with each other — and that's where bugs can creep in over time if you build carelessly.
The good news is that this is a solved problem, and Leo gives you the tools to manage it. Building large software that stays stable isn't about luck — it's about a few good habits. Here are the ones that matter most.
How to keep a large app stable
1. Let Leo write tests as it builds (Test-Driven Development)
The single best habit for a growing app is automated tests — small programs that check your app still works correctly. Leo can write these for you as it builds each feature. Once they exist, a test will instantly flag if a future change accidentally breaks something that used to work. Use Test Builder mode to have Leo focus specifically on creating and expanding your test coverage.
2. Use Ticket mode to plan, then Engineer mode to build
As your app gets more complex, Ticket mode becomes one of your most valuable tools. In Ticket mode, Leo proactively researches your existing code and writes out a clear plan — and a testing strategy — before writing any code. Then you switch into Engineer mode to actually implement the ticket.
This "think first, build second" rhythm is exactly how experienced software teams work on large systems, and it dramatically reduces mistakes. You can read more in the Leo Tools & Features guide.
Tip: Beginner mode is the friendliest place to start. Engineer mode is more powerful but uses more technical language and can feel intimidating. You can switch between modes freely depending on the task — see how Leo's modes work.
3. Run your tests automatically on GitHub
Once Leo is writing tests, you can have them run automatically on GitHub
every time you make a change (via a GitHub Actions ci.yml workflow). This
is a safety net that catches coding errors, broken pages, and regressions
before they ever reach your live app. Your team doesn't have to remember to
run anything — GitHub does it for you on every update.
4. Build on Development, then promote to Production
The biggest protection for a real, in-use application is keeping a separate development instance and production instance. You and Leo do all your building and experimenting on development — where it's safe to make mistakes — and only once you're happy with a change do you promote it to production, the live app your team uses every day.
This means Leo never changes your live app in the middle of the workday, and a half-finished experiment can't take down the system your team depends on. The Pushing & Pulling Updates guide walks through the dev → GitHub → production flow step by step.
Practical limits (and how to lift them)
The framework itself won't be your ceiling. The practical things to keep an eye on as you grow are ordinary infrastructure matters, all easily addressed:
- Server resources (RAM/CPU): a heavier app with more users may eventually want a larger instance. This is a simple upgrade — just email us.
- Database performance: as tables grow, ask Leo to add indexes for the data you search and sort by, which keeps pages fast. See Why Is My App Slow or Frozen?
These are the normal, well-understood levers every growing application uses — not dead ends.
You're not doing this alone
Part of what you're paying for is our support. As your application grows and gets more complex, we're here to help keep it stable, to assist when you hit an issue, and to provide a backstop if Leo makes a mistake along the way. Ruby on Rails is a fantastic fit for exactly the kind of complex business software you're building, and our team is deeply experienced with it.
So build with confidence. Keep adding your modules. With tests, tickets, automated GitHub checks, and a dev → production workflow, your platform can grow as large as your vision — and stay stable the whole way. Questions any time: support@llamapress.ai.