Kotlin Multiplatform / 3 Team Lead Challenges Solved by Kotlin Multiplatform Mobile

3 Team Lead Challenges Solved by Kotlin Multiplatform Mobile

Creating an app is an undertaking that includes not only iOS and Android developers but also back-end and front-end developers along with QA specialists, and for large-scale projects may even involve multi-team work. A team lead supervises and supports all participants of this process. Work management is an endless flow of tasks that can be optimized by using KMM.

Kotlin Multiplatform Mobile (KMM) is a tool that allows you to create business logic for two platforms at once, both iOS and Android. This article shows how team leads can use KMM to speed up development without compromising quality.

What a Team Lead Does in a Project

A team lead serves as a bridge between the business and the developers, providing leadership and support to technical specialists. The role of a team lead is taken by an experienced developer who is at least middle-level but more commonly has reached the senior level. This gives them enough knowledge and skills in development and technology to be able to solve any problem.

Team lead's objectives:

  • Organize a well-coordinated work for all the developers. The team lead plans and distributes tasks based on the specialists' skills.
  • Build workflows. The team lead understands the final goal of the project, and quickly adapts to any changes or force majeure circumstances in order to reach it.
  • Select and apply the best available technologies for the project. The team lead manages the technical development process and decides which technologies to use in development.

It can be difficult to organize the work process, since everything from ideas to deadlines and budget is always subject to change. The team lead faces a constant challenge: they have to figure out how to implement a new feature on a tight schedule without compromising quality or to develop an app for two platforms at once, like with Android and iOS. This is where Kotlin Multiplatform Mobile comes in with its ability to optimize and speed up development by up to 25% and cut the customer's expenses.

Why Team Leads Need Kotlin Multiplatform Mobile

Kotlin Multiplatform Mobile (KMM) is a technology that allows you to write shared code for the business logic and then compile it for native platforms, such as iOS, Android, and others, while maintaining a fully native UI.

Normally, to create native apps for different platforms, developers have to write separate logic and make separate UIs for iOS and Android. As a result, the same app on two platforms can differ not only in terms of UI but also in its functionality and can have unique or matching bugs in the logic. With KMM, all business logic shares the same code, so the apps are guaranteed to have identical behavior while retaining their native OS-based UI familiar to the user.

As indicated by Kotlin Multiplatform track record, developers spend up to 80% of the time writing the business logic and devote the remaining 20% to their platform’s UI.

At IceRock we have implemented Kotlin Multiplatform Mobile and successfully tested it in several projects. For example, when working on Profi, we were able to unify business logic and transfer it to the shared code while leaving the UI/UX native, which saved us development time and cost.

KMM enables the team lead to work faster and helps them fulfill their objectives:

  • coordinating activities of all the developers,
  • supervising the work to minimize bugs, and
  • reducing app development time for each platform.

Objective #1: Coordinate the Work of Multiple Development Teams

Android and iOS are two of the most popular and widespread operating systems. To reach as many users as possible, the customer asks the developers for an app that would work on both platforms (occasionally including the third, desktop-based version). The team lead along with the project manager becomes a bridge between the business (the customer) and the developers.


One project is being developed for two platforms at once, with each team (iOS and Android) working separately. The team lead needs to communicate the same information to the developers who would then produce the same results. However, the resulting apps would often exhibit different behavior for different OS users. This difference in implementation is due to the fact that developers write code separately from each other.


With KMM this problem doesn't arise, since the same business logic code is used on both platforms. The developers can work on tasks simultaneously: for example, one does the logic and the design of the iOS version, while the other one handles just the design of the Android version. With KMM, the user will experience no functional differences between the iOS and the Android app, as the only differences will be found in the interface, standard elements, and system behaviors.

KMM will help coordinate work not only during the development of a new app, but also during the implementation of a new feature for an existing app. For example, if you need to make changes to the logic, all you need is to give the new information to a single developer. Since business logic is shared, a single specialist can make all the changes, which will be seen by other developers.

Objective #2: Monitor Work and Minimize Errors

The team lead's responsibilities include full management of the project's technical specialists, from initial goal setting to inspection of the final result.


When developing a new feature or an entire app for two platforms separately, there may be differences in how the developers implement logic. This results in the numerous bugs revealed at the testing stage.


With KMM this problem doesn't arise, since the team lead only needs to describe the task received from the customer to the developers once. The code is unified, which is why the team lead doesn't need to double check the logic for each platform, and there are fewer bugs.

Objective #3: Speed Up New Feature Implementation or App Development

When a project or feature is developed for two platforms, each team (iOS and Android) works separately. Development teams for each platform write their own business logic and build their own UIs.


Sometimes it's not possible for iOS and Android developers to start working on their versions at the same time, which can lead to project delays until both teams have completed their tasks.


With KMM, the team lead plans the development of the two features in such a way that the developer of one version writes the shared business logic, and the developer of the version for the second platform can use it. This reduces the final product delivery time.

Kotlin Multiplatform Mobile on a Gantt Chart

Let's use an illustrative example to understand how KMM helps a team lead in their work. This example doesn't factor in any weekends or holidays to fit all the days on one screen and provide better visualization.

Let's say we have an app running on multiple platforms, and we need to implement three features: Product List, Profile, and Settings. There is an iOS developer and an Android developer on the team lead's team, with three new features per platform for each of them.

Without KMM, each of the developers would be working on one feature at a time, while having to both implement logic and build UI on their own. Assuming the tasks require the same time to complete and take one day each for the logic and the UI, the developers would finish in six days.

1 eng.png The Gantt chart shows that each developer spends two days on a feature

To understand how KMM could help in this case, let's break down the tasks into three components instead of just two: native UIs for the iOS and the Android platform, and one more task for the shared logic.

On the chart, the components of a feature are marked with the same color, so it's easier to trace the connection. With KMM, the business logic would be the same, but it would be impossible for two developers to do this task at the same time. Let's assign the business logic to the iOS developer, resulting in the following:

2 eng.png The Gantt chart shows that KMM doesn’t help if the tasks are distributed incorrectly

The development time has not been reduced, and the Android developer is constantly waiting for the finished task logic. This kind of distribution may pose problems with logic links during the UI implementation due to the possible differences in the developers' expectations regarding implementation. As a result, one developer would have to make changes in the shared code, which would then have to be synchronized with the code by the second developer, further increasing the development time.

To avoid downtime or delays due to bugs popping up, you need a team lead. They know the customer's goals and assign tasks based on the developers' skills in a way that speeds up development.

In this example, the two features aren't interdependent and therefore can be worked on in parallel using KMM, with one developer tackling the Product List and the other one tending to the Profile. First, each of them will write the logic, test it and adjust it to match the UI for their platform. After that, the developers will swap features and add the missing part to their colleague's work. This is how it would look on the chart:

3 eng.png KMM allows the team lead to distribute responsibilities between the developers and organize their simultaneous work

Now the total development time has been reduced by one day. Simultaneous UI implementation on both platforms can cause errors that would make it necessary to change the overall logic. The team lead reduces these risks by coordinating and checking the developers' work. They get involved at the stage of detailed design and describe the interface between the logic and the UI layer.

And if we take an even number of features, for example, by adding Product Details, the team lead could use KMM to distribute tasks between the developers within the same time and budget parameters.

4 eng.png The Gantt chart shows that with KMM, the developers will finish four features instead of three in six days

Developers value having someone available to build the pipeline: distribute tasks according to the load, keep an eye on deadlines, and provide support in case of mistakes. And for the customers this means getting their product faster and cheaper, as well as the ability to make changes quickly and easily.

With Kotlin Multiplatform Mobile, the team lead can do their job and optimize the work of specialist teams in a more efficient way. To implement Kotlin Multiplatform Mobile, sign up for a free consultation.