Steady Results. Speedy Performance!

We’re Committed to Performance.
As you scale your apps & as we scale our platform, we want to provide an experience that rivals any other app on the market. From the use of the Adalo Editor, to native apps & everything you can create with Adalo, the speed of interactions is important — for your customers & for you, our makers.

Because of the importance of performance, we wanted to maintain a dedicated page to keep you in-the-know in one place. Improving performance is not possible with the flick of a magic wand & instead it’s several projects that will add up to big impact.

Here you will find updates on the projects in progress, the measurable gains we’ve made on speed, and when enhancements have been shipped. We hope our commitment to transparency in this process & this page will help ease your mind.
Just Released!
Improved Performance: Notifications, App Loading, App Analytics, and CSV Exports

Dramatically Reduced Notifications Latency

We optimized our Notifications service and improved latency by as much as 100x in certain cases. This service will now be able to much more reliably handle large batches of notifications.

Improved Loading for Extra Large Apps in the Adalo Editor

We’re continuing to make improvements for loading especially large apps in the editor. In certain cases, some apps would become too large to reliably load in the editor. In most of these instances, the app should now load without timing out.

Faster Loading App Analytics

We optimized our analytics tab for faster and smoother data presentation. Most apps should now see analytics data nearly instantly with little to no lag.

Improved Performance for Large Database Exports

We rebuilt Adalo CSV exports from the ground up to be much more performant. The UI hasn't changed, but it functions much better under the hood! We've also removed the 10,000 record limit for exports. Please keep in mind that especially large exports can still take several minutes to process.

Just Released!
Editor Performance Updates

In our last launch, we improved performance across a number of fronts, all related to apps built in Adalo. This week, we’re following that up with performance improvements to the Adalo editor itself, where you spend all your time building apps. In our testing, apps are loading up to 11x faster!

We have two huge improvements to editor performance going live today:

  • Improved Editor Performance for Apps With Lots of Screens
  • Improved Performance for Editing and Rendering Text

#1. Improved Editor Performance for Apps With Lots of Screens

Our most active users tend to build big apps with several screens. And by several we mean lots and lots and lots of screens. So. Many. Screens! This unfortunately comes with a big hit in performance: the editor slows down or can even fail to load altogether. This was a big challenge, and to tackle it we needed to completely rethink how the editor handles loading screen data. So that’s what we did!

Now, instead of loading all the data for every screen all the time, we’re focusing in on where you’re working and loading only that data. The editor will automatically anticipate your needs as you move around, intelligently loading what you need without the baggage of what you don’t. The result is an incredible improvement in the speed and responsiveness of building in Adalo when you have large apps. We can’t wait for you to try this out. It’s really so much better!

#2. Improved Performance for Editing and Rendering Text

Text-heavy screens were especially problematic and caused the Adalo editor to slow or stall. We’ve reworked how we render text so you can now edit large blocks of copy without experiencing lagging or crashing.

Here you can see an example of an app that has so much text that it stalls the editor and even causes a browser crash. On the right, with the newest rendering changes, the app is performant and keeps up with panning, zooming, and text updates.

Note: To improve text-heavy app performance even further, we always recommend that you store large chunks of text in your database and pull them into your app with Magic Text.

Just Released!
App Performance Updates

We’ve been working on a ton of major performance improvements to both the speed and experience of how data loads in Adalo apps. Today we’re happy to launch the first batch of this work. It’s a lot!

Here’s a high level overview of everything we’re launching today:

  1. Dramatically faster initial list loading times
  2. Instant navigation
  3. Improved loading experiences
  4. Improved create record speed

#1. Dramatically Faster Initial List Loading Times

When you use a list component in your app, that list will not show to the user until all of the accompanying data is loaded. This is fine for when there’s only a few records but if you have thousands of records to display, that initial loading time can be quite long, so long that your users might even think your app isn’t working.

A better and more performant way to do this is to only load some records on the initial screen load and to progressively bring in more as the user scrolls (most modern apps with lots of content use this technique). We now have progressive loading on Simple Lists, Custom Lists, Image Lists, and Card Lists (it was previously only available on Custom Lists). The result is a huge improvement in the initial screen loading time for apps that use these types of lists. In our tests of lists with 5,000 records, we experienced an 86% decrease in the time it takes for the initial load (see our before and after video).

Note that progressive loading is now enabled by default for the list types above, but we did not alter any existing lists in your apps. To enable this feature on your existing lists, click on “Advanced Options” and enable “Load Items as User Scrolls.” You can also disable this feature at any time if it isn’t the best option for your app’s experience.

#2. Instant Navigation

It is absolutely critical that when a user taps a button or link in your app that they get feedback immediately. Otherwise, the app can feel broken or sluggish. Unfortunately, when additional actions are attached to a link action, all of those other actions must complete before the link action can be run. This pattern is the most common reason for apps to feel slow as you navigate around them. We’ve made some improvements here.

As a rule of thumb, you should try to avoid attaching extra actions to link actions if you can. However, sometimes it can’t be avoided and for those cases we’ve optimized the experience so that the link action fires immediately on tap, then goes into a loading state to communicate to your users that everything is working while the actions complete, and then the contents of the next screen are loaded with the data that was just created or updated intact. This may sound like a small change but it makes a huge impact in the feel of your apps and how they respond to taps that change screens. Navigation will now feel instant in most cases. Notice in the demo video how both versions receive a tap at the same time but the improved version on the right responds instantly.

Note that you will need a fresh build to see these improvements in your native apps.

#3. Improved Loading Experiences Throughout Your Apps

Open up your favorite social media app and tap around and you will notice that there are subtle loading states everywhere. These are critical to the experience of using apps. Some data will always take time to load, whether you’re Instagram or an indie app maker. The key is to make sure that when data is loading, the app communicates that something is happening to the user.

We’ve made a ton of improvements in this area. Several of our core components lacked any kind of loading state and simply did not show anything until all the data was loaded. Blank screens aren’t good and make apps feel broken. We have spent a lot of time investing into our components to make sure they show up immediately and communicate when data is being loaded in.

Similarly, when you click on a component, it needs to tell you that it’s doing something! We added visual indicators to lots of components that were missing them. From navigation to action buttons, you should now clearly see that your tap had an effect and the app is working.

The result here is that your Adalo apps will feel much snappier and that your users shouldn’t wonder if actions are running or data is loading. We want to push this experience even further so we will continue to make investments in this user experience.

#4. Improved Create Record Speed

There were some poorly performing actions specifically when creating records that we have optimized, resulting in a notable decrease in the average time it takes to create a record.

Make sure your apps get all the new changes!

Any new app you build from here on out will get these improvements automatically. For your existing apps, make sure you do the following:

  1. Enable “Load Items as User Scrolls” on all lists with lots of records (found under “Advanced Options”
  2. For native iOS and Android apps, run a new build after completing step 1

Looking forward to seeing more performance improvements? We’ll be back soon with some exciting improvements to the Adalo editor.

Performance Work in the Past 12 Months
Previous Updates
Performance work is never finished and is a part of everything we do at Adalo, but below you'll find some of the key performance updates we've rolled out in the past.
Speed up Lists with Counts
Lists that have counts of tables not shown on a screen were causing unnecessary strain on apps, which caused them to slow down. We moved count logic to the backend to help improve the performance of these lists.
Reduced App Sizes
We've rolled out a major overhaul to the way your app configuration is stored that reduced overall app size by nearly 25%! This should especially have gains for apps with a large number of screens and/or components both for editing and running the app.
Improved CSV Upload Performance
Uploading a large CSV to a Collection frequently caused failures and timeouts so we reworked this feature to be more performant and allow for larger uploads. 
Improved Performance Monitoring
We want to continue to make big gains in performance so we’ve taken some time to improve our performance tracking across the board. This will enable us to spot problems easier and ensure that the projects we tackle next will have the largest impact. 
Faster Toggles
Toggles now change state instantly when your users click them!
Text Inputs in Your Apps Got a (Faster) Makeover
Typing in forms and inputs is now blazing fast — especially on web!
Loading User Data Faster in Apps With Lots of Data
We've just sped up all of our large apps that have hundreds to thousands of rows of data. The way we're doing this is by automatically indexing tables whenever you create new collections, which means that your apps will load data in lists, detail views, etc faster than before.
Improved Overall Database Response Times
We've improved database response times by vastly decreasing unnecessary calls to the database. All requests to the Adalo API, editing app data in the editor, and even the initial loads of web apps have all be optimized to take up fewer database resources
Getting Data From Your App's Databases Has Been Improved
We added indexes on the process that associates your app to it's database, making it faster to add and retrieve data.
Initial Load of Web Apps and PWAs Has Improved!
Components are now served through Cloudfront, Amazon's CDN.  Before these changes components could take as long as 8 seconds to download when a user first opened your app on the web. With the CDN, components are now delivered globally with low latency and high transfer speeds (165.92ms average). We also improved the speeds to get the other files your app needs when it first loads like the app icon (233ms to 44ms).
Initial Editor Load Times Are Getting Better
We sped up the initial load time of the editor by optimizing several queries. Here are some additional example areas within the editor that are affected by these changes: lists of custom actions, the team settings modal, and the initial load of your database tables.
Images Load 5x Faster!
We now compress images via Imgix's service to ensure that images are being sent to your apps in a performant manner. Our 5 test images on a screen used to take 6.32 seconds to load. With our changes, those 5 images now take 1.15 seconds to load.
Eliminated Queuing Times for Builds
Before these changes, some iOS builds had to wait 18 hours before they would be processed and published to Testflight, and Android builds were frequently stuck waiting in a queue as well.  Now builds for both Android and iOS start as soon as they're triggered. We did this by preventing a number of builds from failing and by adding more build servers.
Performance Backlog
There’s More To Do
The list below are our current thoughts on what projects we have next, but we’re constantly getting more information & investigating different benchmarks to figure out what to do next.
Skeleton Loading States
We're experimenting with richer loading states that use the popular skeleton UX pattern to provide a better experience when the user is waiting on an initial screen load.
We’d Love Your Help!
Please let us know where in Adalo you’re seeing that things aren‘t loading as fast as you’d like.
Thank You!
We're sorry you're experiencing some slowness, but thank you so sending this over to us. It's really helpful for us when we're investigating.
Oops! Something went wrong while submitting the form.