Mobile Foundation

Platform for teams that create iOS and Android apps repeatedly.

Ship faster than your competitors.

  • Focus on features at day 1
  • Save ~$6,000 per project on setup alone
  • Cut up to 100 hours from time-to-market
  • One architecture across all apps
  • Premium Kotlin Multiplatform starter kit for serious teams
  • Unified tooling: design system, analytics, feature toggles, and more
  • Focus on features at day 1
  • Save ~$6,000 per project on setup alone
  • Cut up to 100 hours from time-to-market
  • One architecture across all apps
  • Premium Kotlin Multiplatform starter kit for serious teams
  • Unified tooling: design system, analytics, feature toggles, and more
bash — 80x24
_
Baselines iOS App

Building mobile apps repeatedly is burning your $$$

Without a foundation, every new project starts with the same invisible waste.

Setup Time
~40 Hours

$2400 wasted per app on setup identical frameworks, CI/CD & tooling.

Development Cost
2x Effort

Building the same features twice for Android and iOS, while still fighting inconsistencies in look and behavior.

Configs & Tooling
10x Reps

Re-configuring builds, integrating same features (analytics, auth, etc.) again and again.

Onboarding
Weeks

Lost to learning arbitrary custom setups.

Repetition without a platform is pure waste.
Cumulative hidden costs often reach an insane $6,000+ per project.

How this hurts different teams

Same root problem. Different consequences.

Pre-sales

Losing deals before start

Competitors show working apps, not promises.

  • Fast POCs win deals
  • Custom setup slows pre-sales
  • Demos increase trust
Hidden cost: lost deals.
Cost

The math nobody calculates

10 apps/year × 1 week setup per app:

  • 400 hours wasted/year
  • $24,000 lost in operational waste
  • Zero competitive advantage
That’s operational waste.

The core problem

All of these issues share the same root cause:

You are building mobile apps repeatedly without a platform.

And without a platform, every new app makes the next one slower.

Baselines solves issues for you ❤️

Engineering cost, time and knowledge transfer issues solved by including best-in-class software in one recreatable bundle: architecture, analytics, feature toggles, app initializers, documentation, tests, and more.

How it works

Streamlined mobile development. Focus on features, we handle the infrastructure.

Clone the Baselines

Pull the repository to access a complete, production-ready mobile foundation - architecture, tooling, and conventions already in place.

Terminal — bash
git clone https://github.com/baselinesio/baselines-kmp.git baselines-kmp
Cloning into 'baselines-kmp'...
remote: Enumerating objects: 124, done.
remote: Counting objects: 100% (124/124), done.
remote: Compressing objects: 100% (98/98), done.
Receiving objects: 100% (124/124), 2.45 MiB | 1.20 MiB/s, done.
_

Instantiate your project

Generate your own baseline. The automated setup applies naming, bundle identifiers, and configurations across platforms.

Terminal — zsh
cd ~/projects && git clone baselines-kmp
python ./baselines-kmp/create_baselines.py
Creating project 'MyApp'... Done.
open -a "Android Studio" ./MyApp
open ./MyApp/app/ios/MyApp/MyApp.xcodeproj
_

Understand the structure

Explore the project organized around clear boundaries - domain, data, UI, and tooling - designed to scale as teams and requirements grow.

app
android
compose
ios
data
...
domain
toolkit
...
ui
...

Build product features

Start implementing features that make you different immediately. Ship faster than competitors. No spending cycles on setup, architecture decisions, or code wiring.

Ship with confidence

Launch a production-ready mobile app that runs natively on iOS and Android. Validate an MVP, demonstrate a real POC, or deploy directly to users — the foundation supports everything you need.

Baselines Tech Stack

Built on top of the latest and most reliable technologies available in the ecosystem.

Core

KMPKotlinSwiftMetro

UI

Jetpack ComposeMaterial 3Jetpack Navigation 2

Data

AndroidX DataStoreSQLDelightSQLCipher

Build System

GradleGithub ActionsConvention PluginsVersion Catalog
KotlinKotlin
SwiftSwift
Jetpack ComposeJetpack Compose
Material DesignMaterial Design
GradleGradle
GitHub ActionsGitHub Actions

Pricing

Free to explore. Pro to ship 10x on a real foundation.

Free

$0

Perfect for learning and hobby projects.

Unlimited projects
Production-ready mobile foundation (iOS + Android)
Enforced architecture, templates, and dependency wiring
Gradle convention plugins for unified build files
Documentation, guides, and architectural rationale
Core tooling: Design system, Navigation, MVVM, Playground, Initializers
Recommended

Pro Mobile Foundation

$999 / year

Professional grade foundation for scaling teams.

Everything in Free
Unified, platform-agnostic analytics tracker
Feature tweaks and runtime configuration
Built-in encryption APIs
Data layer (database + key-value storage)
AI skills for consistent, context-aware code generation
Access to all new platform features as they are released
Priority support with 24h response SLA

FAQ

Baselines is a premium Kotlin Multiplatform foundation - mobile starter kit built by top tier engineers. It gives teams a re-creatable foundation with proven architecture, tooling, and best practices already in place, so teams don’t have to rebuild the same setup for every new iOS and Android project. Instead of spending time and money on foundation work, Baselines lets you focus on the product work that actually differentiates your business.

Baselines is an opinionated platform that provides nice defaults and templates as an add-on.

At the code level, you receive a production-ready KMP mobile foundation. At the product level, you are buying senior mobile engineering expertise and over a decade of experience captured in a reusable system with defaults, patterns, and architectural rules already applied.

A typical boilerplate gives you an empty starting point.

Baselines gives you:

  • Proven architectural decisions
  • Integrated tooling required for real production apps
  • Documentation and rationale that survive team rotation
  • Solutions to problems studios and startups repeatedly face when launching products

It’s not about starting faster once — it’s about building repeatably and sustainably.

Baselines is designed for:

  • Studios launching mobile apps repeatedly for clients
  • Startups validating and iterating on multiple ideas
  • Product teams maintaining and scaling several mobile apps

In short: teams that feel the pain of rebuilding the same foundation over and over.

Baselines makes sense when:

  • You build mobile apps repeatedly
  • You need a foundation that survives team and knowledge rotation
  • You want senior-level architecture, but can’t afford to dedicate senior engineers just to setup work
  • You care about long-term maintainability, not just shipping an MVP

Yes.

The Free tier is production-safe and already used by engineers in real projects. It’s a simplified version that doesn’t include advanced tooling or premium support, but the core foundation is solid and reliable.

The Pro version includes:

  • Priority support with 24h response SLA
  • AI instructions for consistent, context-aware code generation
  • Analytics tooling
  • Encryption APIs
  • Feature toggles / tweaks
  • Advanced data layer (database + key-value storage)
  • Continuous access to new and upcoming platform features

Baselines is a top tier platform that includes a decade of mobile dev experience.

You are not just paying for a code dump. You are paying for architecture decisions, documentation, repeatable workflows, feature modules, long-term maintainability, and ongoing product-level support. If the main goal is the cheapest possible starting point, the Free tier or a lightweight boilerplate is a better fit. If the goal is to start from a high-quality foundation, avoid expensive mistakes and rewrites later, Baselines Pro is built for that.

Yes, but not as an in-place upgrade.

There is no automated migration path from Free to Pro. If you start on Free and later want Pro, you should expect either:

  • starting a new project from Pro, or
  • manually migrating your code and applying the needed changes yourself.

The foundations are compatible by design, but the move is currently manual and should be treated as a deliberate project step.

Yes.

Baselines enforces:

  • Clean Architecture at the project level
  • MVVM + Compose at the UI layer
  • Metro for injecting project dependencies

This removes ambiguity and keeps structure consistent across apps and teams.

Yes.

Baselines is built for Kotlin Multiplatform projects that ship to iOS and Android. It includes shared architecture, multiplatform modules, and UI/tooling conventions designed for real KMP delivery work instead of sample-app scope.

Absolutely.

You fully own the code and are free to:

  • Extend it
  • Modify it
  • Remove parts that don’t fit your needs

Baselines gives structure — not restrictions.

Not directly.

Baselines is currently optimized for new projects. However, you can reuse parts of the codebase and manually integrate them into existing projects if needed.

You do.

All code built with Baselines belongs entirely to you or your client.

Yes.

There are no technical or legal restrictions on modifying or removing parts of the platform.

Yes.

Yes.

Yes.

No.

Baselines cannot be resold, sublicensed, or used to create competing starter kits, templates, or platforms.

Typically less than an hour.

From cloning the repository to running the app on iOS and Android is designed to be fast and predictable.

No.

You only need:

  • Android Studio
  • Xcode
  • Git
  • Python (CLI)

No proprietary infrastructure is required.

Pro users get 24-hour response SLA.

You can — but be honest about:

  • Whether you have enough senior expertise to design a sustainable architecture
  • Whether you can afford the time spent on tooling instead of product features
  • Whether you’ll write and maintain proper documentation as teams rotate
  • Whether your internal solution will keep up with evolving best practices

Baselines already solves these problems — repeatedly, and at scale.

Baselines:

  • Eliminates repeated setup work across projects
  • Prevents senior engineers from being stuck on plumbing instead of features
  • Reduces onboarding time for new developers
  • Avoids costly architectural rewrites later
  • Turns one-time effort into a reusable platform

The result: faster launches, lower long-term cost, and fewer expensive mistakes.