I’ve done two previous posts (here and here) on Google’s Android developer dashboard stats, and I was surprised to find it’s been just over a year since my last one. I may still do a deeper dive revisiting some of the points from those previous posts, but this time around I wanted to do something different – contrast Android and iOS adoption patterns. Google has published data on Android version adoption for quite some time now, but Apple’s only been doing it for the last couple of years, so we have less data. But we still have enough from both platforms that we can draw some interesting conclusions.
iOS adoption – huge initial ramp plus slow conversion
The pattern for iOS adoption is very clear – a massive initial ramp in adoption in the first few days and weeks, followed by a steady conversion over time. The chart below shows the share of the base on each version in the first 24 months from launch:
As you can see, by the time the first month is over, more than 50% of the base is already on the new version, and it ramps to around 90-95% by a year later, just before the next version launches. At that point, it immediately drops to 25-30% as the new version takes over, and slowly dwindles from there down to under 10% after two years. There are differences in adoption rates for the various versions shown – as has been reported, iOS 8 has seen a slower initial adoption rate than iOS 7, though it’s now over 75%. Correspondingly, the share of iOS 7 has fallen slightly more slowly than iOS 6 did, though the gap in both cases has closed a bit recently.
Android adoption – an 18-month slog to significant adoption
By contrast, Android gets off to a much slower start, due to the multi-stage cycle of version releases, work by OEMs, carrier approvals and so on. A similar chart for four recent Android versions is shown in the chart below (I’ve grouped point releases into their dessert flavors, as it were):
iOS hits 50% adoption within the first month, but Android can take over a year to hit 50%, and of the three longer-running versions shown here, only one ever got over 50%. The other interesting thing is that Android versions tend not to peak or hit majority adoption until after a new version has been released. KitKat, for example, just barely became the most used version of Android this month, about six months after Lollipop launched.
Here’s a chart that shows peak adoption rates for three flavors of iOS and Android (bear in mind that iOS 8 is likely about 5 months from its peak, which will occur just before iOS 9 lands in September, and that KitKat
also hasn’t peaked yet, but I’m estimating that it will do so shortly at around 43%):
Now, the reason Apple and Google post this data is to assist developers in deciding which versions of the respective operating systems to target. So what conclusions can we draw from all this as to the best strategies for developers of iOS and Android apps?
Supporting a single version
This strategy wouldn’t serve most developers on either platform very well – it would work better on iOS, where the majority is consistently on a single version of the OS, but even there much of the base would be inaccessible. On Android, this strategy would be disastrous, as single versions rarely get above 50%:
Certainly, the strategy would be more effective on iOS than on Android, because share is consistently significantly higher, but this seems a poor strategy on both platforms. If we make a slight change and now focus on supporting the latest version, things get even worse for Android:
This strategy is obviously completely unworkable for Android, because the most recent version rarely gets above 25% before a new version is released. And supporting a single version, but an older one, is also impractical, since the most attractive users will often be those who upgrade earliest in the cycle.
Support two versions
On iOS, supporting two versions would be an entirely realistic strategy, since the top two versions tend to command an overwhelming share of the base. On Android, too, this would make a big difference, but once again, not as well as on iOS:
Targeting the top two versions of Android captures around 75% or more of the base pretty consistently, but on iOS it captures over 90% of the base and later in the cycle close to 100% of it. Again, though, on Android targeting the top two versions typically doesn’t mean targeting the two most recent versions. That strategy wouldn’t work nearly as well:For iOS developers, however, supporting the two most recent versions is an entirely workable strategy.
Other strategies for Android
The biggest challenge with Android is not just the sheer number of versions that command significant share, but that the newest versions take quite so long to achieve meaningful share. As such, developers who invest in supporting the newest version right away may not see much return on that investment for months at best. However, again, those early upgraders may well be among the most attractive customers because they’re likely committed to the platform and eager to try new things. Leaving them out becauseof their small size probably isn’t the best strategy either. Ultimately, if Android developers want to target 75% or more of the base, they have to support more than two versions, and often four, especially if they want to target new versions immediately. Supporting the last three years’ versions is one way to consistently target 75% or more of the base. But bear in mind, too, that we’ve clustered point releases together in all this analysis: in reality, there are three different versions of Jelly Bean (4.1-4.3) and there are already two versions of Lollipop (5.0 and 5.1), all of which would be included if you were aiming to support the last three year’s releases today.
iOS First still makes a lot of sense
There’s simply no getting around it: developing for Android requires support for significantly more versions, on top of all the other complications like many different screen resolutions and sizes. And we haven’t even discussed the return on investment from targeting a single user or percentage point share of Android versus doing the same on iOS, another area where Android becomes less attractive to develop for. Is it any wonder, then, that major apps (including recent examples Meerkat and Periscope) still target iOS first?