App Updates: Why Do Some Apps Update All the Time?
Users today have the luxury of not having to “deal” with updates in the same manner as years before – many of our apps update quietly in the background by default which has made things better in many ways. The only time most users tend to notice is when an app asks the user to install a new instance from the store which begs the question, “Why?” If your business is planning to release a digital product – or if you’re just curious – you might wonder what’s going on and what impact this has on the product, users, and the business itself.
Apps update constantly, or at least should (to a degree), because of how rapidly things change in technology. Beneath the surface, all kinds of “holes” start to appear as users encounter issues with the software and its integrations, the operating system it runs on, as well as the infrastructure that connects it all. Plus, there’s the hard reality that some folks like hackers may try to exploit weaknesses for personal gain.
So, let’s take a look at why updates are an essential part of a healthy app ecosystem.
Updates keep apps running smoothly
Mobile apps, web apps and,, any OS is a bit like a ship: similar to a Renaissance-era Spanish Armada or pirate ship, over time, maintenance needs to be performed like patching or replacing the sail as well as replacing or plugging damaged planks around the hull. You can manage with a few small leaks for a while but over time, more will inevitably appear. And after too many unmitigated issues, the water level rises and the ship starts to sink faster than you can remove the water.
From here, there’s a handful of more specific spins on this analogy but the point is, updates are used to patch a spectrum of leaks as well as add to or deprecate portions of the app (more on this later.) These leaks can range from an innocuous drip to a gaping hole that’s pouring in dozens of leeches every minute.
A more concrete example of how update cycles can play out is through the Starbucks app in the App Store. if you navigate to the “What’s New” section, you can easily see the version number, release date, and a brief summary of the update. It looks a little like this:
You’ll notice the most recent two are only a few days apart while the second and third most recent updates are nearly three weeks apart. The last four are extremely vague while the oldest two are a bit more specific about what they fixed.
The trend you see is that there is no real trend for updates, with some exceptions. Some improvements, like tweaking formulas or adjusting specific parameters, don’t really need to be detailed to masses which is more than likely the case for the four that indicate they allow the app to run smoother. In the other cases, the two on the bottom provide a bit more insight as to a tangible change the user will actually notice.
As far as the timeframe is concerned, updates following each other in short succession normally aren’t officially planned but should be anticipated – as we’ll explain later, some updates might improve certain areas but hinder or break others. After a release, it’s critical to keep an eye for issues and be ready to release a follow-up if significant issues arise.
As you can see, even a world-class app like Starbucks that’s regularly in the top 10 of all apps in the App Store needs regular updates to keep everything in working order.
The many flavors of updates
Many changes aren’t visible as some will quietly rework parts of an app to be more secure and prevent “leaks” that can be compromised by malicious users, malware, or simply reveal private information. Updates don’t need to be constant, but they do need to be regular.
Fortunately, users today are rarely tasked with manually downloading and applying small updates to their apps unless they’ve configured their device to turn off automatic updates, whether purposely or by accident. However, apps that regularly release new versions or “upgrades” will direct users to the device’s app store which people tend to notice. Let’s look at what each does and how each plays a role throughout an app’s lifecycle.
Updates are usually small in nature but vary in size and scope. Many update packages include several changes that add to, subtract from, or modify parts of the app such as:
Security Improvements. There are all kinds of different ways harmless hobbyists and nefarious lunatics can exploit an app, which you can learn about here if you were so inclined. It’s the responsibility of digital product owners and their teams to stay on top of these matters and make sure your apps stay secure. While this is true for all flavors of software, those subjected to certain data compliance rules, such as healthcare apps that are governed by HIPAA regulations, there’s zero tolerance for leaving loopholes on any attack surface. In other cases, updates are to ensure compatibility with changes to the operating system as well as third-party integrations such as payment processors like Stripe or Dwolla.
There are also times that certain security changes become mandated as a part of a kind of “app law” set forth by both Apple and Google for the App Store and Google Play Store, respectively. All apps living on either store are subjected to the terms and conditions of each. Should an app fail to comply, it can get booted from the store which means extra time and work to get it up and running again.
Enhancing or modifying a feature. Sometimes, a feature doesn’t act as intended but it still “works” – it could stem from UX oversight, meaning the layout needs to be slightly modified, or issues might arise because users encounter some unexpected behavior, (e.g., a menu item doesn’t always open; something that’s supposed to appear after certain conditions are met but doesn’t; etc.) Other times, there are minute changes to bits of code that only make a slight difference (e.g., a new link in a menu, more customization options for items in a food delivery app, etc.) Then there are scenarios where changes have little to no noticeable impact, at least from the user perspective – for example, a more efficient method to call on certain APIs might come with an update and though it saves on bandwidth, most users will never notice. Smaller changes like the above usually fall under the category of general maintenance and are often packaged together in updates that are released as needed.
The double-edged sword here is that, yes, sometimes these will “break” an app for certain users or cause other weird issues to emerge. For example, users that didn’t (or couldn’t) update to Android 10 couldn’t use dark mode apps that relied on Android’s native dark mode tools because they didn’t previously exist. Unless you’re developing a highly specific app for internal business on managed devices, you’ll need to keep pace with updating alongside the rest of the market to be able to take advantage of new resources that become available with time.
Also, there are times that an update does cause new issues, unfortunately, despite making improvements at the same time. And the way these issues are effectively resolved is none other than another update! Hence, it’s critical that your QA team is on the ball to identify and mitigate potential issues before users wash their hands with the app entirely.
Fixing a bug. Little operational nuances happen all the time, even when you have the best QA people in the business reviewing your product. A link in a menu might fail to respond. Maybe a user accidentally enters an emoji in a form where it asks for their age, causing things that “can’t happen” (according to your devs) to indeed happen.
Just like real-life “bugs,” they get into everything but they range from being mostly innocuous, like a fly rudely landing on your falafel, to having an agitated, tropical centipede crawling up your leg. Some are found because of user reports while others are uncovered internally – in either case, they’re prioritized based on assigned value (more on how we do that here) then resolved accordingly. Revised code for these changes is worked into the new source code then later pushed out in an update.
More complex updates
Some updates have a broader scope and replace or change so much code that it requires a new installation from the user. These new versions are packaged to contain all (well, most) previous updates and less fat from trimming deprecated portions that only serve to take up space. In these cases, the user is usually redirected to their mobile app store to download this new version.
Here are a few of the most common reasons apps are updated this method, rather than some background update method:
It’s entirely rebuilt. Though it didn’t make mainstream headlines, Walmart replaced their sloppy, hybrid app with React Native to gain several benefits that would serve to improve performance on both Android and iOS. Essentially, everything about the front-end of the app, which formerly relied on WebView (i.e., it was a glorified mobile web page) to display content, was replaced with a new framework that would allow them to develop efficiently for both mobile platforms as well as access new tools like security features such as allowing them to directly integrate their pharmacy service into the app.
New features or substantial modifications to the source code. Even if you’re not porting to a whole new framework like in Walmart’s case, certain changes mean a fresh slate. When everything is cleanly packaged in a new version, it should be much “cleaner” which makes it easier to support and scale. For example, a restaurant with its own mobile ordering app might want to eventually build a custom delivery service or integrate a third-party solution like DoorDash – in either case, adding new libraries and making substantial changes will eventually mean releasing a new, fully updated version of the app.
A major layout change. Certain changes to visuals like moving items around in a menu, adding or removing bits and pieces, or changing visual elements don’t usually require an entirely new version. However, a massive overhaul can mean uprooting and changing core elements of code that both display the UI and makes it functional. As such, most major design changes will require a new version of the app.
In certain cases, developers will force users to install an update or entirely new version. The reasons for this vary but are largely in the user’s best interest. For example, when deprecating a certain portion of an app, there’s no reason for a user to be able to access remnants of a defunct service. It’s also useful when data compliance is a concern and an update fixes a vulnerability – here, only the latest version(s) is/are configured to connect and run to prevent a potential exploit.
Another good example is found in gaming, especially with online multiplayer components. Popular games will often update daily during the prime of their lifecycle to ensure that players are competing are able to have consistent synchronization on servers and that things “stay fair.” Teams tend to closely monitor things like how much damage a certain item does (or doesn’t do) both through analytics and feedback gathered from gaming communities, whether internal or part of some subreddit. Updates are often forced to apply new parameters that “buff or nerf” (i.e., make stronger or weaker) certain things in multiplayer settings that can give players an unfair advantage.
Simply put, forcing updates can be for the best when there is a risk or significant deficiency present in older versions as this keeps users and the platform safer.
Because a lot goes into successfully supporting and growing an app, those looking to bring a digital product to the world will be a lot better equipped to navigate the decisions and challenges that come along with maintaining, updating, and improving their app. By understanding that it’s an ongoing process that’s never perfect – even for the best teams! – this helps manage expectations which can help minimize stress for teams and even keep matters like technical debt from turning into an issue.
We design & develop apps to grow with your business and users
Updates are just part of the game. Fortunately, those offering digital products on major app stores don’t need to pound on user’s doors every time a small update is required, à la older systems. However, new versions will be needed every so often as well to keep users engaged. At Blue Label Labs, we’re well-seasoned from the years of building and supporting many successful products – you’re looking to bring your own idea to the market, then get in touch!