Key Takeaways: How a Fast-Growing Enterprise Enables Multi-Team Development with KMP and Type-Driven Design

Building mobile apps in agile teams working under tight deadlines is never easy. Managing multiple feature teams, ensuring high-quality code, and keeping development efficient can quickly become overwhelming, especially when targeting both iOS and Android.

In a recent webinar, we explored how Trackman, a sports technology company, successfully solved these challenges by combining Kotlin Multiplatform with type-driven design.

Here’s a detailed recap of the session, with insights from their staff engineer, Yeskendir Salgara, on implementing KMP at scale, overcoming technical hurdles, and speeding up cross-platform development.

Meet Yeskendir Salgara

Yeskendir Salgara, staff engineer at Trackman (Denmark), has 8 years of iOS development experience across fintech, consulting, and crypto domains. He joined Trackman with a mission to enable feature teams to work faster and produce higher-quality apps. During the webinar, he shared his experience implementing KMP, creating a modular architecture, and fostering cross-platform collaboration in a complex environment.

Q: Why Did Trackman Choose Kotlin Multiplatform?

Yeskendir: When I joined Trackman, we were facing the challenge of supporting multiple platforms while keeping our development teams productive and code quality high. I had worked with Kotlin Multiplatform about five years ago, and I knew the benefits of a shared codebase. Kotlin and Swift share many concepts, which made learning and transitioning easier for iOS developers.

The main idea was simple: write once, run everywhere, but we wanted to make sure it worked in practice. We adopted a metrics-driven approach, tracking DORA metrics (deployment frequency, lead time, change failure rate, and time to restore) to measure efficiency. At the same time, we monitored App Performance Metrics like app size, launch time, build time, and runtime performance to ensure the user experience remained top-notch.

Choosing KMP wasn’t just about sharing code; it was about enabling teams to move fast, reduce duplicated work, and maintain the flexibility to innovate on each platform independently.

Q: How Did You Structure the Architecture for Multi-Team Development?

Yeskendir: One of the biggest hurdles was ensuring that multiple teams could work in parallel without blocking each other. We decided to share only the business logic layer across platforms while keeping the UI layer platform-specific. This meant that iOS and Android developers could implement interfaces the way their platform intended, but the core logic was consistent across both platforms.

For features that could benefit from shared UI, we also experimented with Compose Multiplatform, which allows reusing UI components while maintaining native look and feel. The KMP code is compiled into XC Frameworks, which are then wrapped in Swift Package Manager (SPM) modules and injected wherever needed.

By organizing the project in a modular architecture, each feature team could develop independently. If a new platform feature came out, teams could adopt it without breaking existing modules. This approach reduced long-term risk and kept teams agile.

Q: What Role Does Type-Driven Design Play in Development?

Yeskendir: Type-driven design was a game-changer for our team. The core principle is: if it compiles, it works as intended. We create types that represent business states and logic, and we use mappers as checkpoints to eliminate invalid states.

This approach significantly reduces the feedback loop. Developers catch mistakes at compile time rather than during testing or after release. For example, if a developer misses handling a specific business state, it becomes immediately obvious because the compiler will flag it. This also improves collaboration with QA and product teams because the code reflects the expected behavior precisely, reducing ambiguity.

iOS uses the Composable Architecture (TCA) and Android uses Circuit, which aligns well with type-driven design principles. By structuring code in this way, we maintain high quality while enabling teams to move fast.

Q: What Challenges Did You Encounter with KMP Implementation?

Yeskendir: While KMP brings huge benefits, it also introduces technical challenges. The biggest one is type conversion between Kotlin and Swift. KMP produces Objective-C code with some overhead, which can create type erasure issues. For instance, arrays are becoming NSArray instead of Swift arrays. To overcome this, we use the Sky library, which helps translate enums and other types cleanly into Swift.

Another challenge was getting Swift developers to write Kotlin for business logic. Many were unfamiliar with Kotlin syntax and idioms, so we had to introduce practical learning sessions rather than purely theoretical ones. Despite these challenges, the benefits of sharing business logic and maintaining platform-specific flexibility outweighed the difficulties.

Q: How Do iOS Developers Adapt to KMP?

Yeskendir: Our approach is practical, task-based learning. Developers are given real features to implement in Kotlin, and their work is reviewed through pull requests, which doubles as a learning session. This helps them understand not just how to write Kotlin, but why certain patterns are used.

We also use AI tools to speed up learning, providing support with syntax, patterns, and documentation. But AI is only a helper; understanding the code, architecture, and business logic is still the most important skill. Creating a supportive environment where mistakes are part of learning has been critical for successful adoption.

Q: How Is AI Used in Your Development Process?

Yeskendir: AI is useful for a few things. It helps with generating documentation, writing tests, and even translating features across platforms when the architecture is similar. But we don’t rely solely on AI. We have multiple guardrails, including linters, automated tests, architectural tests, and detailed code reviews.

The real focus is on developers understanding the code deeply. AI speeds up the process but doesn’t replace human reasoning or problem-solving, which is essential when implementing complex business logic across platforms.

Q: What Do You Look for When Hiring Developers for KMP Projects?

Yeskendir: When hiring, we don’t prioritize prior KMP experience. Instead, we look for developers who are curious, proactive, and able to learn quickly. They need to understand business requirements and ask meaningful questions. A deep understanding of technology is valuable, but attitude, problem-solving skills, and the ability to learn new tools matter more.

This approach has helped us build a team that adapts well to cross-platform development while maintaining high-quality standards.

Q: Are There Best Practices or Resources for Learning KMP?

Yeskendir: There are a lot of tutorials and sample projects, but the key is adaptation. Read articles, follow experienced developers, but don’t expect one solution to fit all projects. Always question existing patterns and apply what works for your team’s specific context.

We’re also developing project templates for KMP and CMP to help teams quickly get started and reduce setup overhead. Learning KMP is not about copying someone else’s code, it’s about understanding principles and applying them in your environment.

Key Takeaways: Overcoming Enterprise Challenges with KMP

Enterprises developing mobile apps often face common pain points: development teams functioning independently without cross-team collaboration, duplicated effort across platforms, slow feature delivery, and difficulty maintaining code quality. Trackman’s experience with Kotlin Multiplatform shows how these challenges can be addressed strategically.

By implementing KMP, Trackman was able to share business logic across iOS and Android, reducing duplicated work while still allowing platform-specific UI. This approach enabled multiple feature teams to work independently, solving the pain point of bottlenecks in multi-team development and accelerating delivery without sacrificing quality.

Type-driven design further improved development efficiency. By catching bugs at compile time and enforcing business logic through types, developers avoided long feedback loops and reduced the risk of runtime errors. For enterprises struggling with quality assurance and bug management, this methodology provides a measurable way to maintain high standards.

Adopting KMP wasn’t without challenges. The team had to overcome technical difficulties in converting Kotlin types to Swift, including type erasure issues and Objective-C overhead. They resolved these issues using the Sky library and created practical learning processes for iOS developers to adapt to Kotlin. This addresses the pain point of skill gaps in cross-platform teams, showing that hands-on learning and review processes are crucial for successful adoption.

Trackman also used AI tools to speed up development, assisting with documentation, writing tests, and translating features. However, the webinar highlighted that human understanding of the code and architecture remains critical, addressing the enterprise concern of over-relying on AI without proper review.

Conclusion

Trackman’s journey shows that Kotlin Multiplatform isn’t just a technical choice but a strategic shift in how enterprises can scale development across multiple teams while maintaining flexibility and quality.

If you’re exploring cross-platform approaches and want to understand how KMP compares to other technologies like Compose Multiplatform (CMP), make sure to check out our blog on KMP vs CMP - it breaks down both options in detail and helps you decide which fits your next project best.

At Aetherius, we’ve applied these same principles in our own work. Over time, we’ve built a collection of mobile app templates we’ve tested on real projects, and every time, they saved us hours by eliminating repetitive setup work that every new app normally requires.

Now, after a year of refining and testing, we’re finally ready to bring everything together in one place. Explore all mobile app templates on the MobileKit website.

Whether you’re an enterprise scaling multiple teams or a startup getting your first app off the ground, the right combination of KMP, clear architecture, and reusable app templates can help you move faster, without sacrificing quality or control.

And if you need KMP or CMP experts to build your cross-platform app with confidence that everything will work exactly as intended, or you’d like to migrate your existing native app to a cross-platform solution, feel free to get in touch with us.

Our developers are ready to onboard in a maximum of 5 days, so you can start building without delay!

‍