Skip to main contentSkip to footer
    Back to Case Studies
    SoccerTrak by Pre-College Development Academy
    Lovable to MobileiOS and AndroidSports

    SoccerTrak

    SoccerTrak is a player development platform for soccer, built in Lovable by Pre-College Development Academy. The owner wanted iOS and Android apps without a second code base. I built the native apps, the live updates and the store work around his Lovable app.

    Project Preview

    Live website preview - soccertrak.io

    1
    Code base for the website and both apps
    4
    Checks before an update reaches a phone
    15
    Store screenshots, 4 device sizes
    6 days
    To store ready builds

    One code base

    The apps load the same web build as soccertrak.io inside a native shell. Same screens, same accounts, one backend.

    Publish once, update everywhere

    A Publish in Lovable reaches the installed apps as a live update. No store release for a screen change.

    Gated releases

    Each build passes 4 checks first. A build that fails one check never reaches a phone.

    Push and app links

    Push through Apple and Firebase from one backend function, and links that open a screen of the app.

    Store requirements

    Account deletion, report and block, consent before AI, an age rule and a privacy manifest.

    Phones and tablets

    iPhone, iPad, Android phones and tablets, checked on Android 16 and 17.

    The problem

    SoccerTrak serves players, parents, coaches, club directors and college coaches. It holds player profiles, fitness tests, match stats, training plans, team chat, camps and tryouts. The owner builds it himself in Lovable, and the website was live at soccertrak.io.

    Players and coaches use their phones at the field, so the owner wanted apps in the App Store and Google Play. A rebuild in a mobile framework would split the product into two code bases. Each change would then need to be made twice, and the owner could no longer change the apps himself in Lovable.

    What the owner needed

    • Keep Lovable: He continues to build in Lovable. The apps follow his Publish button.
    • No broken phones: An update must not reach the installed apps if it fails to start.
    • Pass the store review: Apple and Google have strict rules for apps with accounts, user content, AI and young users.
    • Native features: Camera, location, motion, files, push notifications and app links.

    What I did

    I put a native shell around the web app. The iOS and Android apps load the same web build that the website uses, so the screens and the accounts stay the same. I then built the update system, the native features and the store work around it.

    One Publish in Lovable updates the website and both apps. The App update workflow checks the build, then Capgo sends it to the installed apps. A native change needs a store release.
    How a change goes from Lovable to the website and to the installed apps
    SoccerTrak on iPhone: the player home screen with Profile and Performance
    Player home
    SoccerTrak on iPhone: college readiness scores and fitness for a sample player
    Performance
    SoccerTrak on iPhone: match stats and a team comparison
    Match stats
    SoccerTrak on iPhone: team chat with club announcements
    Team chat

    Store screenshots on iPhone. The players and teams are sample data.

    What I built for SoccerTrak: 175 commits in 6 days, a Capacitor 8.6 shell, live updates and push. Also Android checks, store requirements and store assets.
    The work at store ready state

    How it was done

    A native shell, not a second app

    The shell is Capacitor 8.6, with the iOS project on Swift Package Manager and the Android project on target API 36. It lives in its own folder in the owner's repository, next to the web app. The store apps load the bundled build, not a website address, so they start fast and work as a real app.

    A small bridge in the web code tells each screen what the phone can do. Camera, location, motion, file selection and push use the native plugins on a phone and the browser on the website.

    Live updates with gates

    A GitHub workflow compares the live commit of soccertrak.io with the version in the apps. When they are different, it builds the published commit and runs 4 checks: the bridge tests, the plugin versions, the start signal and the sign-in screen. Only a build that passes all 4 goes to Capgo, which sends it to the installed apps.

    I tested an update, a delta download and a rollback on the iPhone simulator and on the Android emulator. If a new version does not send its start signal, the app goes back to the last good version.

    Store requirements in the product

    Account deletion in the app, and a public page about it
    Report and block for chat messages, profiles, videos and clips
    A report button on each AI result
    Consent before any data goes to an AI provider
    A filter for objectionable words in texts that other users read
    A minimum age of 13, and private player photos and videos
    An iOS privacy manifest and a data inventory with the evidence for each item
    No in-app purchase: memberships are sold on the website only

    I also checked who can read each kind of player data. Now only the player, a parent, the team, the club, the staff and college coaches with a verified .edu address can read it.

    Changes through GitHub, safe for Lovable

    The owner continues to edit in Lovable, and Lovable commits each edit to the same repository. Each of my changes had to work with the other parts in their old state, because a Publish, a backend deploy and a database change happen at different times. For each change that Lovable must apply, I wrote the exact prompt for the Lovable chat.

    SoccerTrak on an Android tablet: the club roster with sample players
    The club roster on an Android tablet, with sample players

    If your app is built in Lovable

    The same method works for any web app or site built in Lovable. You keep the tool that you use today, and you get apps in both stores.

    You keep building in Lovable

    Your screens stay in one place. A Publish updates your website and your apps.

    Most changes skip the store review

    Only a native change, such as a new permission or a new icon, needs a store release.

    The store work is done for you

    Store requirements, privacy forms, screenshots, listings and signed builds.

    Updates are checked first

    A broken build stops at the checks and never reaches the phones of your users.

    Where it stands

    What I can and cannot claim

    Both apps build, start and pass their checks on the iPhone simulator, the Android emulator and an Android test device. The signed store builds are ready. The apps are not in the App Store or Google Play yet, because the owner's Apple and Google developer accounts are still in setup.

    Push notifications work on Android. iOS push needs the owner's Apple key. Tests on more real phones are planned with the first test release. I do not have download or user numbers to publish yet.

    What This Project Does Well

    Native iOS and Android projects on Capacitor 8.6, with no change to how the owner builds in Lovable
    Live updates tested on both platforms: an update, a delta download and a rollback
    Signed iOS archive and Android release bundle built by script, ready for the owner's store accounts
    Store requirements for an app with accounts, user content, AI and young users, in the web code and the backend
    Player data read rules checked before the store review
    A runbook, a store listing draft and a step plan for each store, so the owner knows each next step

    Technologies Used

    Lovable (React, Vite, TypeScript) and Lovable Cloud. Capacitor 8.6 with Swift Package Manager and Android API 36. Capgo live updates and GitHub Actions. Apple Push Notification service and Firebase Cloud Messaging.

    Ready to Build Something Similar?

    Let's discuss how we can help transform your business with a custom digital solution.