Distributed mobile team collaboration: Code & design reviews, architecture discussions, and continuous practice

In November 2025, mobile engineers from our Tokyo and Ho Chi Minh City (HCMC) Development Centers came together for FIXIT, an intensive three-day workshop. This workshop created a space for genuine technical exchange, where Tokyo members facilitated discussions on architecture and practices, while LINE Vietnam engineers challenged assumptions and shared fresh perspectives from their projects.

The results exceeded our expectations: participants rated the workshop highly for overall satisfaction. More importantly, the workshop sparked debates, revealed shared challenges, and created lasting connections between engineers who now collaborate more closely than ever.

Why FIXIT?

As our engineering teams grow across different locations, maintaining consistent code quality and architectural practices becomes crucial. FIXIT aimed to create a space for genuine technical exchange:

• Share knowledge both ways: While Tokyo members introduced software architecture principles and modern practices, HCMC engineers brought fresh perspectives and challenged assumptions
• Strengthen communication: Build personal connections and establish regular collaboration channels between different offices
• Align through discussion: Work together on real problems to discover shared approaches rather than enforce standards

The participants

The workshop brought together engineers from both Development Centers:

From Tokyo:

• Android engineers focusing on code quality and modern UI frameworks
• iOS engineers focusing on code quality and architecture design

From LINE Vietnam:

• Android teams
• iOS teams

Day 1: Welcome and code challenges

The workshop kicked off with team introductions. Everyone wrote an introduction on a page with interesting facts and photos, then shared verbal introductions with the group. This dual approach, both written and spoken, helped everyone remember names and build connections that would prove valuable over the coming days.

The highlight of Day 1 was the "Spot the Bug" game. We were presented with side-by-side code samples in Kotlin and Swift, each containing subtle but important issues. The challenge? Identify the bugs before they make it to production.

The game generated lively engagement with extensive discussion and numerous reactions across all problems. We actively discussed the code samples, sharing different perspectives on the same bugs and learning from each other's insights.

Try it yourself: Can you spot the bug?

Here's one of the problems we presented:

What's the bug?

Both implementations have the same critical issue: when removing an element during iteration, the loop index doesn't adjust for the shortened array. This causes the loop to skip the element immediately after each removed item, potentially leaving some blocked users in the result.

Better approach:

// Kotlin: Use filter
fun excludeBlocked(users: List<User>): List<User> {
    return users.filter { !it.isBlocked }
}

// Swift: Use filter
func excludeBlocked(users: [User]) -> [User] {
    return users.filter { !$0.isBlocked }
}

This exercise sparked great discussions about defensive programming, the importance of using built-in functional programming methods, and how similar patterns appear across different languages.

Day 2: Deep dives and hands-on practice

The second day dove deep into technical topics that impact daily development work:

Morning: Architecture and code review

The morning began with a code review presentation on conceptual circular dependencies (article in Japanese, English version coming soon). What made this session valuable wasn't just the presentation, but the discussion that followed. HCMC engineers shared examples from their projects, and we discovered that circular dependencies often hide in unexpected places like naming conventions and conceptual coupling, which enriched everyone's understanding.

Next came an introduction to the LINE mobile app's architectural framework for system design, built specifically for LINE app features. Using quiz questions connected to real projects, we explored software design concepts together. But the real learning happened when HCMC engineers questioned how these patterns apply to their specific use cases, challenging us to think through edge cases and practical implementation strategies. The session included an open invitation to participate in ongoing architecture framework discussions, and the strong interest showed genuine engagement rather than passive listening.

Due to the rich discussions and debates, we didn't have time for the second planned code review topic, which was a good problem to have because it meant genuine exchange was happening.

Afternoon: Platform-specific workshops

Android track: Jetpack Compose workshop

The Android teams worked through a comprehensive Compose workshop covering:

• Fundamental components: LINE app custom theme implementation, LINE Design System (LDS) semantic colors, and pressed states
• LINE Design System integration: Hands-on practice with LDS components, with guidance on how to request missing components
• Edge-to-edge support: Critical considerations for modern Android UI
• Custom themes: Supporting variations like the Brown theme in the LINE app
• Preview and testing: Screenshot testing techniques that generated particularly strong interest

The hands-on format allowed everyone to practice with real code, ask questions about specific scenarios, and discuss how these patterns apply to their current projects. The screenshot testing discussion led to plans for clearer documentation to help teams adopt this practice more easily.

iOS track: Live code review and design documents

The iOS workshop covered practical code review techniques through live examples:

• Pull request best practices: The importance of small, focused commits over large monolithic changes
• You aren't gonna need it (YAGNI) principle: Only add code or flexibility when actually needed, not when you think it might be needed
• Practical tips: GitHub shortcuts like pressing i to hide comments, and the value of fetching code to review in your IDE for full context rather than only reviewing on GitHub's web interface
• Design document review: What should be included in refactoring docs, including detailed as-is (current state) issues and step-by-step to-be (target state) plans, not just the final state

The live code review format sparked good discussions about how these principles apply to different project contexts and team workflows.

Evening: System design and team dinner

At 5 p.m., both tracks reconvened for a system design session. We explored the architecture of a real feature, discussing data layers, component structure, and technical trade-offs. The discussion touched on crucial topics like information ownership (determining which component should handle specific information) and strategies for dealing with ambiguous requirements by defining clear policies for unclear points.

Day 3: Creating together

The final day put everything learned into practice through hands-on collaboration.

Morning: Continuing the system design discussion

Day 3 began by completing the system design session from the previous evening. We dove deep into a feature design document, examining:

• State management strategies for complex features
• Synchronization challenges and their solutions
• Approaches for handling difficult technical problems
• Information ownership patterns (connecting back to the circular dependency discussion from Day 2)
• How to handle ambiguous requirements by defining clear policies

Mixed team design document sprint

Following the morning session, we formed four mixed teams (two Android and two iOS), each combining members from different development teams. Tokyo members joined each team as advisors. This mixing was intentional: it broke down silos between teams and encouraged knowledge sharing across the entire LINE Vietnam Development Center.

Engineers didn't just work on theoretical exercises; they collaborated on design documents to optimize real components and features used by millions of LINE users. Each team:

1. Analyzed current issues and technical debt in production code
2. Brainstormed solutions together
3. Wrote a complete design document
4. Reviewed within their team

The chosen directions included:

• Converting UI to Jetpack Compose for better maintainability
• Applying architectural patterns to improve testability
• Better separation of concerns for easier future changes
• Modularization strategies to support team scalability

All four teams successfully completed their design documents. Survey results showed participants gave exceptionally high ratings to both the peer review process within teams and team collaboration.

Follow-up plan

Due to time constraints, the planned cross-team presentations were moved to upcoming weekly live code review sessions. This actually worked out well because it extends the workshop's impact beyond the three days and provides an immediate use case for the regular collaboration sessions we're establishing.

What we learned about distributed teams

This workshop taught us valuable lessons about building genuine technical collaboration across distributed teams. These lessons emerged from mutual exchange rather than one-way teaching:

Learning by doing

Among all activities, the team refactoring exercise was the clear favorite over presentations and demonstrations. We believe the best architecture isn't just documented; it's built together through hands-on practice. When we worked together on real problems, we didn't just learn technical concepts; we learned how our counterparts think, how they approach problems, and how to communicate across cultural contexts. The design documents created during these sessions became artifacts of shared understanding, not just technical specifications.

Common ground exists in unexpected places

The "Spot the Bug" game revealed something fascinating: despite working thousands of miles apart, on different platforms (Android and iOS), and in different languages (Kotlin and Swift), we face remarkably similar challenges. The same loop iteration bug appeared in both codebases. The same circular dependency patterns emerged in discussions. This realization that our struggles are universal broke down barriers faster than any icebreaker could.

Software design needs context, not just documentation

Introducing architecture patterns works best through dialogue, not declaration. The quiz-based approach sparked conversations where LINE Vietnam engineers challenged assumptions and shared their implementation constraints. These questions, such as "How does this handle our specific case?" and "What if the requirements change mid-project?", weren't obstacles to learning; they were where the real learning happened. Tokyo members refined their understanding by explaining these design principles through this new lens, while their counterparts saw how abstract patterns solve concrete problems.

Building global trust

Technical excellence is the foundation, but personal trust is the accelerator for our global teams. While our teams regularly collaborate through video calls, the three days of in-person interaction created a different quality of connection. The casual conversations during lunch, the whiteboard debates, and the team dinner built trust and rapport that will make future remote collaboration more effective. Virtual meetings work better when we can picture the person on the other side, remember their interests, and understand their communication style.

The workshop is just the beginning

The real measure of success isn't satisfaction scores; it's what happens after. Weekly live code review sessions are now being established. Design documents created during the workshop are being implemented. We're staying connected across offices. The workshop created momentum for ongoing collaboration, not just a one-time knowledge transfer.

Conclusion

FIXIT demonstrated that effective collaboration across distributed teams requires genuine exchange. Engineers from both offices came together to share experiences and learn from each other. Their insightful questions improved our understanding of design challenges and edge cases. Their practical implementation experiences helped refine our Compose documentation. Meanwhile, Tokyo members gained insights from seeing how patterns are applied in different project contexts and learned better approaches to theme handling.

The workshop created visibility and connections that led to tangible outcomes: one LINE Vietnam engineer joined the global architecture framework discussions following the workshop, bringing their architectural expertise to shape the future of LINE's native app development alongside engineers worldwide.

Perhaps most importantly, the workshop showed that technical excellence emerges from diverse perspectives. The "Spot the Bug" game reminded us that we face similar challenges despite different contexts. The mixed-team design document sprints proved that we can quickly align on complex technical problems when we bring together different experiences and approaches.

The overwhelming interest in future workshops tells us this is just the beginning. As we continue with weekly live code review sessions and follow up on the design documents created during the workshop, we're building a model for genuine collaboration between peers, where questions are welcomed, assumptions are challenged, and everyone contributes to our collective technical growth.

FIXIT took place November 19-21, 2025 at our HCMC Development Center, bringing together mobile platform experts from Tokyo and LINE Vietnam engineers for three days of collaborative learning, technical exchange, and genuine partnership.