My AI-built app got slow when real users arrived. What do I fix first?
Short answer: Fix the cheap things first, in this order: oversized images, screens that load every row of a list at once, screens that make dozens of separate requests, missing database indexes, and database connection limits. In my experience a slow AI-built app is often slow for one or two of these rather than all five, and the first two are usually hours of work, not weeks. Measure one slow screen with a stopwatch before you change anything, and measure it again after each fix.
Your AI-built app worked fine with a few testers and now slows down or fails as real users arrive, and you want the order to fix it in.
I'm Ranjit, and I run Blur Studio: 15+ years building software, 120 apps taken live, and clients who have gone on to raise $10M+. I build AI systems and processes that help businesses do a lot more with a lot less time. I also work differently from most of what else is out there, more on that further down this page. Say hello.
An app that is fast for you and slow for customers is a very common stage. The app was built to look right with ten rows of sample data and one user. It was never tested with ten thousand rows and fifty people at once. The good news is that the causes are few and they repeat. This guide gives you five of them in the order I would check them, what to look for without being a developer, one worked example, and a clear point at which to bring in help.
Tools like Lovable, Bolt and Replit (AI app builders where you describe an app in chat and they write the code) and Cursor (an AI coding editor) are good at getting a first version running. In my experience they do less to plan for growth. Supabase, a hosted database and login service built on Postgres (a widely used database), is a common choice for these apps. I use it in the examples, but the same ideas apply to other databases. If Stripe events are going missing, see how to fix Stripe webhooks in an AI-built app.
Step zero: find out what kind of slow it is
Before you fix anything, spend ten minutes on these checks. They tell you where to look.
- One screen or every screen? If only one screen is slow, the problem is almost always on that screen's data. If everything is slow, suspect the database connections or the server size.
- Slow for everyone or only on phones? Slow only on phones and on mobile data points to heavy images and large files.
- Slow all day or only at busy times? Slow only when many people are on points to connection limits or a server that is too small.
- Slow after a quiet spell, then fine? Some hosting plans treat idle apps differently from busy ones. Check your host's plan page for what it says about idle apps.
- Time it. Open the slow screen in a private browser window, start a stopwatch when you click, stop when the page is usable. Write the number down. For a page's main content, Google's web.dev guidance treats 2.5 seconds or less as a good time for Largest Contentful Paint, the moment the biggest item on the page appears.
If you want to be alerted before your users complain, see how to know your website is slow or down before customers tell you.
Fix 1: image and file weight
The symptom: the page is slow on phones, or the screen jumps around as pictures arrive. The cause: a photo straight from a phone can be several megabytes, and AI builders often use it at full size. The check: open the browser's developer tools (right-click, Inspect, then the Network tab), reload, sort by size. As my own rule of thumb, anything over about 300 KB for an ordinary picture is a suspect. The fix: shrink and resize pictures to the size they are shown, and use modern formats. The web.dev guide on optimizing LCP lists compressing an image or switching to a more efficient format such as AVIF or WebP as ways to shorten the image's load time. It also warns that this only improves the page's LCP time if loading the image was the slowest part, so time the page again after the change. Our guide on shrinking huge photos automatically shows how to set this up once.
Effort (my rough estimate): 1 to 3 hours. Cost to ignore: every visitor pays it on every visit.
Fix 2: lists that load everything at once
The symptom: a table, order list or feed that was quick on day one gets slower each week, and a busy customer's page is the worst. The cause: the screen asks the database for every row and lets the browser deal with it. With 40 rows, that is fine. With 40,000 it is not. The check: ask whether the slow screen shows a list, and whether anyone ever scrolls through all of it. The fix: ask for 20 to 50 rows at a time (pagination, meaning "page 1, page 2"), add search and filters that run in the database, and load more only on demand. You can tell Cursor or your builder: "Change the orders list to load 25 rows at a time with next and previous buttons, filtered by date in the database query, not in the browser." Then test with a big pile of sample data, not five rows.
Effort: 2 to 6 hours per list screen. Where a human checks: make sure the totals at the top of the page, such as "total sales", still use the full data and not just the visible 25 rows.
Fix 3: one screen making dozens of requests
The symptom: one page is slow even with little data, and the Network tab shows dozens or hundreds of small requests. The cause: AI-written code often fetches a list, then fetches details for each item one by one (developers call this the "N plus 1" problem). Ten items means eleven requests, a thousand means a thousand and one. The fix: fetch the related data in one request, or load details only when someone opens an item. The check: count the requests when the slow page loads. As my own rule of thumb, more than about 30 to 40 for one screen is worth a look.
Effort: 3 to 8 hours for a screen. This is the first fix I would hand to a developer if the code is tangled, because the change touches both the screen and the data it asks for.
Fix 4: missing database indexes
The symptom: a screen with a modest number of rows is slow, and it got slower as the table grew. The cause: an index is like the table of contents of a book. Supabase's own documentation explains that an index lets the database find a row without scanning the whole table, and that without an index Postgres scans every row to find matches. Indexes are not free: they add some extra writing and storage, so the docs advise understanding when to use them. In my experience AI builders rarely add them beyond the automatic one on the main ID.
The check: Supabase's query optimization guide says to run the explain command on a slow query and look for slow parts such as sequential scans or high cost numbers. It also notes that if a new index does not reduce the cost of the query plan, you should remove it. The Supabase Dashboard also has an Index Advisor, found on its Query Performance page, which suggests indexes to add. Columns used to filter, join and sort are the usual candidates.
A related fix for apps with logins: access rules called row level security policies run on every query. Supabase's documentation recommends writing the user lookup inside a select, as (select auth.uid()), and limiting a policy to logged-in users with to authenticated, which stops the rule from running for anonymous visitors. Ask your developer to review the policies on your busiest tables.
Effort: half a day to 2 days, mostly spent finding the right queries. Where a human checks: never add or change indexes or security policies directly on a live database without a backup and a test copy.
Fix 5: database connection limits
The symptom: the app works for a while, then pages fail with errors about too many connections, usually at busy times. The cause: every request needs a connection to the database, and each plan allows only a certain number. Supabase's performance tuning guide says the default connection limits depend on your compute size, and that if there are too few connections you will get an error when connecting. Its connection guide says that serverless and edge functions open many short-lived connections and should use the shared pooler in transaction mode, while a persistent back end can connect directly. A pooler is a middleman that shares a small set of connections among many requests.
The fix: check where your code runs and pick the matching connection method from Supabase's table, and avoid opening a new connection per user click. Supabase's connection management guide also gives a general rule: if you rely heavily on its REST API, be careful about raising the pool size past 40 percent of the database's maximum connections, otherwise you can commit up to 80 percent to the pool. Supabase describes those numbers as generalizations, so check them against your own peak use.
Effort: 2 hours to 1 day. A bigger server plan can buy time, but if the app opens connections wastefully a bigger plan only delays the next crash. Check your provider's pricing page for the current cost of a larger size.
A worked example (made-up figures)
A small online course business has an AI-built dashboard. In testing, the "students" screen opened in 0.8 seconds with 40 students. With 6,000 students it takes 9 seconds, and at busy times it fails. The owner times it and a developer reviews it.
| Step | Finding | Fix | Time after fix | Assumed developer time |
|---|---|---|---|---|
| Start | All 6,000 rows loaded, 4 MB of profile pictures | 9.0 s | ||
| 1. Images | Pictures shown at 80 pixels but stored at 3,000 pixels | Resize on upload | 7.5 s | 2 hours |
| 2. List | No paging | Load 25 at a time | 1.8 s | 4 hours |
| 3. Requests | One request per student for course status | One combined request | 1.2 s | 5 hours |
| 4. Index | Search by email scans every row | Add an index on the email column | 0.6 s | 3 hours |
| 5. Connections | New connection per request | Switch to the connection method that suits serverless code (the shared pooler) | 0.6 s, no more failures | 3 hours |
The numbers are invented to show the shape of a typical fix, not a promise. Total: 17 hours. At an assumed $100 an hour that is $1,700, and the first two steps, 6 hours or $600, did most of the work. Your own numbers will differ, but the pattern of cheap fixes first usually holds.
When to bring in a developer
- You have done the images and lists and the app is still slow.
- Errors appear only at busy times and you cannot reproduce them.
- The app handles payments or personal data. A change made in a hurry can open a security gap, so read the why AI-built apps break list first.
- Your builder keeps "fixing" the problem and adding new ones.
- You are moving from a test setup to real customers. See how to move an AI-built app to production and what makes a vibe coded app production ready.
Hosting also matters. If the app sits on a plan meant for hobby projects, see where to host an AI-built app. And if you are weighing whether to keep prompting or hand it to a person, vibe coding versus hiring a developer lays out the trade-off.
How I'd approach this
I would time the slowest screen, then work down the five fixes in order, timing again after each one. I would not upgrade the server first. It is the most expensive fix, and it only helps when the app is already well behaved. I would also add a simple load test before launch day, so that the first time fifty people use the app is not the first time anyone has tried it.
If you want a developer to do the review, a fixed-scope pass over the slowest three screens and the database is a good first job. Blur Studio fixes and finishes start around $1,500, with the price agreed in writing before work starts. I would also tell you if the app is better off simplified than scaled.
Questions people ask
Why is my AI-built app slow when more people use it?
Often because it was only tested with a little data and one user. The common causes are large images, lists that load every row, screens that make many separate requests, missing database indexes and connection limits. Start with a stopwatch on one slow screen, then work down the list above.
Do I need a bigger server?
Rarely first. A bigger plan helps if the app is well behaved but short of memory or connections. If the screens load far more data than they need, a bigger plan only delays the problem. Fix images, lists and indexes first, then look at your provider's pricing page.
What is a database index in plain words?
It is like the table of contents of a book. Supabase's documentation says an index lets the database find a row without scanning the whole table. It speeds up reading, and costs a bit of extra storage and writing, so add them where you filter, join and sort.
My app crashes when many people use it at once. Is that the same problem?
Often it is a connection limit. Each request needs a database connection and each plan allows only a certain number. Using the connection method that matches where your code runs, including a connection pooler for serverless code, is the first thing to check. See why AI-built apps break for the other usual suspects.
Can I fix this myself with Lovable, Bolt or Cursor?
You can often do the image and list fixes yourself by asking the tool for something specific, such as paging 25 rows at a time. Leave indexes, security rules and connection settings to someone who can test them safely, especially with real customer data. See vibe coding versus hiring a developer.
How long does it take to make a slow app fast?
Image and list fixes are often hours of work, and the full five-step pass in my worked example is about two to three working days. Those are made-up figures for illustration. A developer's review of your own screens will give you a real estimate, so ask for one in writing.
More in this topic: Problem solving: AI-built and no-code apps (26 guides) →