I’m Building for Shipaton 2026: Two Weeks In | Darryl Bayliss’s Blog

I'm Building for Shipaton 2026: Two Weeks In

2026-08-13

kotlin

ios

hackathon

It’s the 2nd week of Shipaton and I thought it was a good time to take a moment to document my progress on the submission.

Note: This is the 2nd post about my work towards shipping an app for the Shipaton 2026 hackathon.<br>If you want to read from the beginning you can find the link to the first post here

As a recap I’m building a multi-layered application using the following technologies:

Kotlin Multiplatform (Shared Kotlin Library, handles networking, file storage and business logic)

iOS App (iOS app built using SwiftUI, focuses on the UI layer and consumes the Kotlin Multiplatform library for its business logic)

Firebase Backend (An all-in-one backend using Firebase Cloud Functions for endpoint creation / webhook event handling, Firebase Cloud Messaging for push messaging and Firestore for backend persistence)

Let’s start with what I have. I have a working app, complete with an onboarding flow that guides you through linking your GitHub account to the Buildhorn GitHub app (more on that later!). Once you’ve given permission to access your selected code repositories, Buildhorn can monitor workflow events for those repositories via a webhook and push the information to the app.

Once you are through to the home screen you are shown a list of your monitored repositories where you get the latest build status. You can also create iOS widgets to show the status for each repository outside of the app.

The monitoring is done via the Firebase backend, where Cloud Functions handle much of the GitHub authentication and synchronisation. Information about what repositories to monitor and the run status for each are stored in Firestore.

The free version limits users to connecting two repositories. I still need to hook up RevenueCat to enable users to connect unlimited repos. It’s not a pretty app but it works, and the polish will come in the next few weeks.

Here’s a video of how it looks in action:

Your browser does not support the video tag.

Let’s dive deeper and look at how each part of the application is getting on.

Kotlin Multiplatform

The first thing I wanted to do was create a stable foundation for the project. That meant setting up the Kotlin Multiplatform library and configuring it correctly to make sure communication between KMP and iOS was seamless and issue-free.

To start, I installed the KMP Plugin for Android Studio and used the Kotlin Multiplatform template from the new project wizard to get my project set up.

The template does a good job of setting you up with everything you need. It creates the KMP shared library, as well as the native apps for iOS and Android that are preconfigured to pull in the shared library. You can even run an iOS app straight from Android Studio and use the debugging tools to debug your KMP library, very handy!

One part of the starter project I had to remove was the built-in wiring for Compose Multiplatform. I want my project to leverage the best practices of each native UI framework, which meant Compose Multiplatform unfortunately didn’t have a place here.

Fortunately, a few prompts to Claude made removing Compose Multiplatform an easy job, keeping the iOS UI using SwiftUI and updating the Android app to use the Jetpack Compose libraries, in case I want to build an Android app later.

Next on the list was to find suitable dependencies for the library. I want KMP to own as much as possible in the data and domain layer, that means things like local data storage, dependency injection, view model management, Firebase interaction, and of course RevenueCat subscription management.

To figure out what was available, I used klibs, a website dedicated to cataloging KMP libraries. After some browsing, I ended up using:

AndroidX Data Store

AndroidX ViewModel

Kotlin Firebase SDK

RevenueCat KMP SDK

Koin

With that I had my tools to begin working on the business logic. For the architecture I’ve opted for a traditional Android api / impl architecture to lean into my existing Android / Kotlin skills.

iOS App

With the KMP starter project setting up the iOS App, all I had to do was begin working on the SwiftUI screens and hook up the viewModels exposed via the shared library. I started off with the onboarding screens where I began to run into a few interesting questions.

First, how do I link my user’s GitHub installation to my app, and what do I do if I want to send them push messages? I decided to keep things as light as possible and use Firebase’s anonymous authentication so at least I have an ID to use that’s linked to a user’s GitHub installation. That way I can start generating push tokens for later, it also streamlines onboarding.

Another issue that arose was making sure calling through to the Kotlin library felt idiomatic in Swift. There are translation issues, particularly when you start using Kotlin’s suspend...