TL;DR: We developed Uppy, an on-premises way to distribute Android and iOS apps via the open web. The SDK for iOS is here and the one for Android is here, whilst the backend will be published later because it needs a bit more polishing! 😜
I’m so excited to unveil this project publicly that I’d like to go straight to features, but first, let me introduce some of the backstories!
Why we built Uppy
As you may already know, internally we are developing two apps: one for customers and one for shoppers and while the first one is publicly available on major stores, the other one has very specific needs that can’t be achieved on those platforms.
Specifically, we value the shopper app as a Working tool with a capitalized “W”, meaning that the app should be not only as efficient as possible but updates must be on-point and align with regulations and new features in a timely fashion.
Imagine this scenario: A physical store changes the way shoppers of Everli should pay, or identify themselves at checkout and let’s imagine that we need to display some instructions in the app, if everything was already in place then the backend could send these instructions, and the app would display them somewhere. However, let’s say that this kind of structure is not yet in place, then you need to introduce this feature via an update and the update must arrive quickly in the hands of shoppers.
In this scenario, waiting for Apple or Google’s review before the update gets published would mean that we have to compromise on development time (and its quality) in order to be sure to have the update online where the shopper actually needs it. Another example might be where we need to force an update on all the users because a new law or regulation applies to everybody.
Therefore, Uppy was essentially built to provide shoppers with reliable and timely updates.
Of course, before starting writing our own solution we wondered if something already existing was fitting our needs and, as a matter of fact, we were happy customers of Applivery for a while (they are awesome, check them out 😜)!
However, as you might have read already here, during the pandemic our numbers were off the charts, and also the number of people that had to work with the shopper app increased by the day, hence we realized being fully in command of the update process was key to be able to scale freely.
But enough back story! What can Uppy do?
Features sneak peek
Without further due, let’s dig into a few features!
Create and download an app
The most basic need that Uppy solves is to have a unique link where people can download and install an app.
In order to do that, an Uppy user can register an app through the dashboard and then upload a build for both iOS and Android (or just one of them).
Being notified about updates
Another basic need that can be solved via Uppy is to let users know when an update is available. This functionality requires that apps integrate the Android or iOS SDK we provide. In fact, when our SDK is added to an app, a developer can choose to
have control over what and when to display updates or it can simply choose to let the SDK handle everything automatically (more info can be found on the Readme of every SDK repo), convenient right?
Require everybody to update
Sometimes you need to make sure that all the users are using the latest version of the app, in this case an update can be “forced” from the dashboard and everybody who is using an older version will be required to update.
Schedule a release
We don’t want to bother users with updates and their pop-ups while they are working, and nobody wants to upload updates at a specific time, so this is a specific feature we always wanted from Applivery. Of course, this feature was built in Uppy from the get-go and it’s actually pretty easy to use! Just set a time in the “Available from” field when you upload a build and it’s done.
There is much more
I didn’t even mention other basic features because they are pretty straightforward, but here’s a small list of what we already support:
- Analytics: you can get the number of downloads and of actual installs per each build.
(Interesting plus: it’s opt-in and doesn’t send the data anywhere besides your server)
- Deleting a build: never happened to push a broken update, right? 😜
- Responsiveness: The whole dashboard scales well on any screen (unlike others 😁)
On open-sourcing Uppy
The open-source ethics is such a big part of our culture: our CTO likes and would like to use Linux again, most of our backenders use it daily, and even the people who use OSX or Windows owe so much to the community and open-source in general that we all felt like this project was a good way to give back.
Basically, we never even questioned the fact that this project couldn’t be open-source!
Besides, we saw that working on an open-source project boosted morale and we think it also pushed and challenged the boundaries of quality standards we were used to, which greatly reflected on other projects.
If you’d like to dive deep into our code, both iOS and Android SDKs are freely
available (here and here), whilst the backend will be published later. This delay in opening the backend code is due to the fact that after we saw Uppy working, we got so eager to use it, that we ended up hardcoding some configurations that we would like to remove before people can start installing the project on their servers. So stay tuned to know when it’s going to be openly available!
On the future of Uppy
We consider Uppy still in its infancy, and we feel like it is an MVP. Features that we would like to add soon, in no particular order, are:
- Multi-language support
- Customizable Branding options
- More charts and insights (for the ever-wanting Product Managers 😜)
However, really, we would like to shape its future with the community, so be sure to check out the code and every contribution will be welcome!
Hope to see many and Thank you for reading!