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.
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.
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.
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.
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:
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!
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.
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!
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.
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.
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.
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.
Any new app you build from here on out will get these improvements automatically. For your existing apps, make sure you do the following:
Looking forward to seeing more performance improvements? We’ll be back soon with some exciting improvements to the Adalo editor.