Codos app

Make every commute count.

“Codos aims to help motivate people to take on climate change by rewarding every sustainable work commute. The Codos app calculates the amount of CO₂ avoidance by your choice of sustainable transportation, and rewards you with new Codos tokens.”

We hope this message inspires you as much it did us!

Our client came to us with just a couple of screens of new designs and an iOS app that was already deprecated. We took on the challenge to build out the Android app, from the ground up! We’ve setup the architecture, helped refine the designs, created breakthroughs in the areas of blockchain and engineering best practices, and helped drive the focus towards the important things.

Now we have an app that’s rock-solid and feature-rich. We’re adding new features daily and helping Codos expand and reach their goals.

• Date: June 2023
• Client: Codos
• Category: Greentech, Blockchain, Telemetry, ML
• Tech: Android, Kotlin

Close Project

DoctorCare Anywhere

Health advice at your fingertips.

What do you do when you inherit a 3 year old app that’s already full of legacy code? You roll up your sleeves and get to work!

While working with DoctorCare Anywhere, we’ve helped them get their app from a stable but hardly maintainable app to a highly resilient and easily extensible project. How did we do it? It wasn’t easy..

• We needed to start with tests - there weren't any! The first 100 were the most difficult, but after we got rolling it became easier and easier.


• Next came the refactors - slowly but surely, while still doing active development we carefully replaced component by component and system by system. From Handlers and AsyncTasks to modern tools like Retrofit, Coroutines, and Flows. From God classes and logic-filled views to a modern MVVM architecture


• Automation - it's a huge time-sink to stop all work and manually create a release every time, don't you think?


• Code quality gates! It might sound boring and unimportant, but it's the best way to ensure the quality of the codebase (and test coverage) stays at a high level and increases incrementally.


• We pushed hard and worked with the product team on education and prioritization. During our time, we managed to have the mobile apps get recognized as a first-class citizen. The apps stopped being an afterthought, and designs slowly moved from imitations of web pages to a real mobile look and feel.


• We worked closely on each step of the development process - design meetings, technical grooming, estimations, execution, team leadership and many more.

It’s an understatement to say DoctorCare Anywhere was our proving ground. We have only gratitude and admiration for their team and project. We’ve helped each other grow immensely, and for us they will always hold a special place in our history.

• Date: April 2018
• Client: DoctorCare Anywhere
• Category: Medtech, VoIP
• Tech: Android, Kotlin, Java

Close Project

Transportation app

Case study of a transportation app

This seemingly unassuming project turned out to be exceptionally interesting and challenging in the best way possible! The great thing is it was a greenfield project - so this allowed for plenty of freedom.

Here’s a breakdown of this project:

1. Final mile carriers (the people who transport your package from the post office to your house) needed an automated system of keeping track of packages.


2. Bills of lading (a list of packages inside a given vehicle) needed to be scanned and their data sent to the BE.


3. Packages needed to be scanned when loaded and delivered.


4. Geofencing needed to stop drivers from scanning packages or bills of lading in location where they were not allowed to.


5. We needed to support iOS and Android.

Kotlin Multiplatform was chosen as the framework for this job. In order to reuse as much code as possible and keep the apps functionally the same, we designed an architecture which puts as much code as possible into the shared part of the multiplatform project.

This allowed for all the business logic, database, network code, error handling, and threading to occur in a single place, and only expose data towards the UI which was Swift or Compose for iOS and Android, respectively. Google’s MLKit was used for image recognition, and Google Location for the geofencing.

What’s interesting to note for this project, is that it required a whole different approach to the usual way an Android app is built. The architecture forced good design (by separating the app into layers), and had a lot of interfaces which had different implementations depending on if it was being used on the iOS or the Android side. Also, the library stack needed to completely change, as these types of projects require pure kotlin libraries, so mainstays like Retrofit, Hilt, and Room were not available.

It’s safe to say that the project was a success, and that we’ve grown a lot by doing it!

• Date: June 2022
• Client: NDA
• Category: Transportation, Machine learning
• Tech: Kotlin Multiplatform

Close Project

Logistics app

Case study of a logistics

Imagine a warehouse, with thousands of packages coming in every day. It’s a midpoint, a stop a package makes between a company and it’s customer. In this case, it’s critical for a package to get sorted quickly and correctly so it arrives on time and on the right address. Let’s dive in.

There were a couple of angles to consider with this software:

1. Hardware. The hardware needs to be specialized, and we used devices manufactured by Zebra to provide scanning and printing interfaces.


2. Who will use the software. In our case, it was the workers at the ground floor of the warehouse. This means that the interface needed to be sized so it's accessible with gloves, that the errors messages need to be large and very descriptive, and that the UI needed to be simple and intuitive.


3. Performance. It's essential to have the performance be as fast as possible, as we want a fast answer from the BE about where to place the package or pallette next.


4. Robustness. We can't have any errors crashing the app, or have the app enter into an unrecoverable state.


5. Peripherals. Connections to peripheries needs to be stable but also flexible. There's no guarantee that, for example, the same device and printer will be picked up every time. In fact, it's quite the opposite.

With all these requirements, we still found time to setup a proper quality gate, add tests, improve the architecture and increase stability. So much so that the client decided to do another project (this time from scratch).

• Date: January 2022
• Client: NDA
• Category: Logistics
• Tech: Android, Kotlin

Close Project