Sessions List

Open-source frameworks are increasingly shaping the Android ecosystem, offering alternative solutions to Google’s standard libraries. This session will examine the practical benefits and trade-offs of adopting open-source frameworks at scale, addressing key gaps they fill and how they influence architectural decisions in mobile teams. >What is the current industry balance between open-source frameworks and standard Android libraries? >What challenges do state-machine architectures like Circuit, Workflow, and Appyx solve for mobile orgs? >How do open-source frameworks impact long-term maintainability, scalability, and team onboarding? >What are the key architectural bottlenecks in Android development today, and how do these frameworks address them? >trelWhat organizational investment is required to adopt, maintain, or contribute to open-source frameworks?

The Credential Manager API has seen significant adoption since passkeys arrived on the scene. Now, Android is taking user authentication to the next level by expanding support across the entire ecosystem, from phones and watches to cars and TVs. In this talk, we'll explore how the Credential Manager API is evolving to enable seamless and secure sign-in experiences on Android Auto, Wear OS, Google TV, and beyond. We'll dive into the latest API capabilities, showcase real-world examples of successful implementations, and demonstrate how you can leverage these advancements to simplify user journeys and enhance security in your own Android apps.

Many small productivity improvements add up. Focusing on your personal developer productivity. "Small things" we will talk about: - better error messages - Filing better bugs - "Ask for help" better - Learning keyboard shortcuts

Repetitive tasks, complex command-line actions, and the need to enforce team standards often disrupt the development workflow and force the developer to leave their IDE. Integrating essential tools and documentation directly into the IntelliJ IDE offers a significant productivity boost by minimizing context switching and streamlining common processes.This lightning session demystifies IntelliJ IDE plugin development, demonstrating its accessibility. It will cover how to get started with building practical, simple plugins using patterns and frameworks you already know today such as Compose.

Paparazzi has established automated screenshot testing as a standard industry practice, catching countless regressions early. However, at Cash App, we've recognized that traditional screenshot tests still fall short when validating high-fidelity, touch based interactive experiences or user interfaces that depend on Android's system UI, such as navigation bars or soft keyboard insets. These limitations often force us back into manual testing, allowing subtle yet impactful bugs to slip through. To bridge this gap, we've been exploring "interactive" animated paparazzi tests, which automate real-time gestures like taps, swipes, and even custom drawings to simulate how real customers interact with our UIs. Additionally, we've built a realistic fake version of Android's system UI that renders the navigation bar, status bar and soft keyboard within our paparazzi tests. This system dispatches accurate insets, allowing us to verify that our UIs react appropriately. In this talk, I'll demonstrate how these improvements are significantly reducing our manual testing overhead, catching complex UI regressions earlier, and bringing automated paparazzi testing environments closer to the fidelity of real devices.

Engineers and developers are tasked with deploying AI models, face a variety of unique challenges. One of the most important considerations is the creation of a reliable and repeatable feedback loop, allowing new data to be collected to improve model accuracy. This talk will cover some of the popular solutions and strategies to help establish an MLOps process and workflow for your unique use case.

Discover how Microsoft built Copilot, an AI companion, using modern Android architecture. We’ll dive into key design decisions, Jetpack integration, and optimizations that enabled a scalable codebase. We will be conducting demo and a QA session at the end.

Android, often the first personal device many own, and is a powerful tool for learning about application development. It comes loaded with sensors (accelerometers, gyros, microphones, and a high-resolution camera). When you pair these sensors with Edge Impulse, a platform, that recently joined forces with Qualcomm Technologies and simplifies the process of developing and deploying machine learning models on devices that can operate dependent from access to the internet or “at the edge”, you have the perfect, low-cost launchpad for starting your AI literacy journey. In this 80-minute workshop, you will: 1. Learn how to collect and label your dataset from your Android device sensors. 2. Train a fall-detection model with the Edge Impulse platform using your dataset. 3. Export and configure your model as an Android studio project, so it can be utilized locally on your device. 4. Install the Android package (apk) 5. Have the tools to continue your journey to vision-based models and visual inspection. You will walk away with a functioning distributable application (apk), a repeatable workflow for future projects, and the confidence to extend your new skills to any Android form factor, from classroom tablets to factory-floor industrial devices. Join us in the democratization of AI literacy.

Building and testing apps for Android has specific requirements and unique challenges. Accelerating your mobile development process results in lower costs, happier developers, and quicker releases for your customers. Join me as we explore using build cache, parallelization and other critical approaches that drive efficiency in your CI/CD workflows; compare metrics, and learn practical tips to foster faster feedback loops and quicker iteration cycles.

From punch cards to touchscreens, the evolution of UI is a story of constant adaptation to bridge the gap between our intentions and the machine's capabilities. This talk will draw parallels between the pivotal shift to mobile-first, touch-based interfaces that revolutionized Android development and the impending transformation driven by AI-powered UIs, aiming to prepare Android developers and designers for this crucial next step. I'll discuss conversational interfaces, explaining how natural language interactions, are becoming integral to the user experience. I will examine adaptive UIs, where AI enables interfaces to dynamically adjust, creating truly personalized and efficient interactions. These AI-driven paradigms are not just trends, they will fundamentally reshape how we design and interact with digital products. Attendees will leave this session understanding that just as the transition to mobile demanded new ways of thinking about layout, interaction, and user context, the integration of AI will require a similar adaptation. This presentation will help Android developers and designers prepare for the challenges and opportunities presented by AI so they can build the intuitive, intelligent, and effective user interfaces of tomorrow.

Get answers to all your pressing questions in Q&A sessions with Google's Android DevRel team.

Gradle's scalability is critical to maintaining fast and efficient Android builds at scale, both in local development and continuous integration environments. In this roundtable discussion with experts from Gradle, we will explore recent and upcoming performance improvements, and how developers can stay ahead of the curve. Let's look at: >How do recent features like the Configuration Cache impact everyday build performance for Android developers? >What challenges and opportunities do upcoming efforts like Isolated Projects present for teams working at scale? >How can developers optimize their inner and outer development loops using existing Gradle capabilities? >What long-term strategies should teams adopt today to prepare for the next wave of Gradle performance enhancements?

Get answers to all your pressing questions in Q&A sessions with Google's Android DevRel team.

As Android development evolves, release management must transform with it. In this unconference-style discussion, we'll examine how teams are reimagining the release process for modern Android development. Together we’ll explore emerging best practices in release automation, monitoring, and orchestration. We'll answer questions like: >How can you achieve tighter collaboration between engineering, QA, and product and unlock faster cycles, clearer ownership, and a more resilient release? pipeline. >How are other companies using these approaches to ship more frequently than competitors while spending less time on releases and experiencing fewer hotfixes.

This session shares our on-going experience implementing on-device TensorFlow ML capabilities through Kotlin Multiplatform to serve both our Android and iOS native SDKs. We'll explore the technical challenges around KMP and the current state of ML on KMP, architectural decisions around common KMP integration issues like code management, iOS framework binding and outputs. Learn how we brought a team of data scientists into a Kotlin-based workflow and leveraged AI tooling to accelerate their learning curve, established efficient code practices, and relied on comprehensive testing for ML code using KMP.

If you’ve been in the workforce long enough, you’ve probably had at least one bad boss and if you’re lucky, you’ve had at least one great boss. What is it about the good ones that inspired you? What did they do to establish themselves as leaders? What made you want to work hard for them? In this session we’ll explore the qualities of true leadership. You’ll walk away with strategies on how to inspire your teams and you’ll learn that you don’t have to wait for the promotion or the “management title" to show up as a leader.

Get answers to all your pressing questions in Q&A sessions with Google's Android DevRel team.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. In this discussion, we'll review the state of Jetpack Compose adoption in 2025. At this point, an overwhelming number of companies are using Jetpack Compose, but many still have legacy view system screens to manage. Given that we still have work to do, let's get together and discuss: > What's the current level of Compose adoption on your projects? > What plans, if any, do you have to migrate legacy screens to Compose? > How are you managing View/Compose interop during this process? > What complications are presenting additional migrations to Compose? > Is a 100% migration to Compose a bad idea? (spicy takes!)

Learn to build robust and engaging text experiences in Jetpack Compose. This session covers the state-based TextField API, Autofill integration, dynamic text resizing with AutoSize, custom input and output transformations, and more. Discover how you can use these powerful APIs to create seamless and delightful user interactions.

Configuration changes are foundational to app behavior, and the closely related behavior of Activity recreation and lifecycle create the structure guiding architecture on Android. With recomposition in Compose and some brand new tools along with new Android 16 changes, apps can opt out of recreation for many types of configurations and handle configuration changes better than ever before, with benefits and opportunities for both the developer experience and the user experience. Learn how and why to opt-out of recreation, and also cases to look out for where it might not be quite so straightforward.

How do you make sure finished work is actually a job well done? Not just with Result.Success( )! This talk will cover how to reliably execute tasks in the background using modern Android APIs. Learn what situations are better suited for WorkManager vs JobScheduler and the fundamentals of scheduling and debugging a worker. We’ll also explore how to examine the reliability of your jobs and workers using specific metrics, and what data you can start collecting today to glean insights into your app’s overall background task efficiency.

The Firebase AI SDKs provide access to the Gemini Pro and Flash models for text generation and Imagen for image generation. Integrating these models into your app can enable you to easily implement compelling intelligent functionalities that were previously difficult to achieve for Android developers. We also launched the new Gemini Live API enabling low-latency bidirectional streaming to support voice interactions with Gemini. We will also cover the latest on the Gemini Nano API for on-device inference. In this talk we will cover these capabilities in detail and review how you can integrate them into your production Android app.

Stop by and chat with Stacey Devino and grab some advice on how to take ownership of your career path. Find out what skills you need to succeed, what the winning formulas are and find out how to avoid pitfalls.

Google Play Console is evolving its core vitals to include battery drain signals! Excessive wake lock usage will be joining user-perceived crash and ANR rate as key signs of your app’s technical health. You’ll want to plug-in as these metrics can affect the visibility of your app on Google Play. Learn how to use performance tooling and new APIs to detect and reduce high power drain use cases such as location or background syncs. As well as how to improve app stability by reducing crashes and ANRs.

AI is quickly transforming how engineers work. See how Duolingo's Android team uses common AI tools like Cursor and ChatGPT through practical examples, from prototyping UI from Figma to transliterating iOS logic. We'll discuss results from the team, touch on Duolingo's evolving engineering culture, share limitations in today's AI tools, and close on opinions for using AI in Android engineering.

Presentation software is extremely powerful, full of creative styling, powerful animations, and plenty of other things. Yet every time I wrote a new presentation, I found myself repeating something with almost every slide; whether that be the content, styling, or animations. Wanting the torment to end (and a different kind of torment to begin), I wrote my own presentation framework with Compose! But wanting to be like all the cool presenters, I needed something like Keynote’s Magic Move for all my code examples! Compose has SharedTransitionLayout, how hard could this be? So I built my own version of Magic Move. And rebuilt it. And rebuilt it again. And Again. (And probably again between submitting and actually giving this talk) Let’s look at all those different iterations, the improvements each brought, and why diffing algorithms are hard.

In this talk, we will unveil our journey of optimizing Android WebView to reach performance levels comparable to native pages. We achieved this by refining resource loading, API requests, and page rendering processes. A key breakthrough in our efforts is a feature we dubbed "Native Worker." By harnessing Native Worker to parallelize the execution of JavaScript code, we significantly slashed WebView rendering times. These enhancements led to performance boosts of over 50% for more than 70% of the Web pages within TikTok, with some specific pages even experiencing performance gains exceeding 100%. Join us to explore how these cutting-edge optimizations can bring your WebView performance to the next level.

At Block, we have spent the past several months creating an LLM driven mobile testing framework, “Trailblaze”. It has enabled Square and Cash to run natural language based instrumented tests for Android both locally and in our continuous integration pipeline. This has allowed us to reduce manual effort for authoring and executing tests. This talk goes deep into the inner workings of Trailblaze as we share our lessons learned while building it. Learn the strategies we use to communicate effectively with the LLM and have it decide how to drive the user interface. Mobile AI driven tests are no longer science fiction, it’s here, works well, and will only get better. Come learn from our experiences and find inspiration to leverage AI to make your testing efforts more effective.

AI is rapidly transforming the software development lifecycle, offering new ways for developers to build, test, and maintain applications more efficiently. From monorepo-aware coding assistants to agentic systems for large-scale code migrations, and from AI-generated tests to probabilistic agents reshaping quality strategies—this panel dives into the cutting edge of AI-powered developer tools. You’ll leave with actionable strategies for implementing AI in your own workflows, and practical ideas for driving meaningful productivity gains across your teams. >What does “AI-driven productivity” look like in practice across the software development lifecycle? >How can coding assistants be customized to work effectively in complex environments like monorepos or large codebases? >What are agentic AI systems, and how are they being used for tasks like large-scale code migrations or refactoring? >How is AI reshaping the traditional test pyramid—from the ground up with code generation, and from the top down with probabilistic testing? >What are some low-lift, high-impact ways mobile teams can start integrating AI into their workflows today?

In this live-coding talk, we’ll engage both iOS and Android Rive animation engines, and we’ll do it all using Compose MultiPlatform. Together, we’ll convert a static image into a walking character using animation “bones” rigging, inverse kinematics, scale transformations, and path constraints. Breathe life into your mobile apps using character animations!

While Jetpack Compose simplifies UI development with its declarative paradigm, mastering its reactive nature, particularly optimizing recompositions and managing state hoisting, presents costly challenges for developers transitioning from imperative approaches. Subtle mistakes can lead to performance issues, and verifying efficient composition through testing remains challenging at scale. This session tackles these challenges head-on by diving into the world of Kotlin Compiler Plugins. We'll demonstrate how to build a custom plugin that hooks directly into the compilation process. Learn how to analyze Kotlin's Intermediate Representation (IR) to identify Composable functions and automatically inject instrumentation and recomposition tracking code before your app even runs. We will construct a practical compiler plugin designed to: >Track and visualize recomposition frequency using a heatmap, instantly highlighting performance hotspots. >Enhance unit tests by enabling assertions on specific recomposition counts, ensuring stability and efficiency. Attendees will leave understanding: >The core concepts and power of Kotlin compiler plugins. >Setting up a plugin project and integrating it via Gradle. >Analyzing Kotlin IR to target specific code structures like Composables. Join this session to unlock a powerful technique for building custom developer tooling, improving your Compose development experience, and shipping higher-quality, performant UIs to your users.

When working on UI, you want to see the results of your code changes as fast as possible. Waiting for apps to rebuild and relaunch, then getting the app to the desired state again only gets in your way. Compose Hot Reload is a new JetBrains project that gives you live updates after code changes when running a Compose app on desktop - so you can see and feel how your app’s behaviour changes, without having to relaunch it at all. And you even get to keep your existing state! In this talk, we’ll experience coding with Compose Hot Reload enabled with exciting live demos, and also learn a bit about how it all works under the hood. If your project doesn’t have a desktop target yet… it might just be time to add one!

As Android development teams grow in complexity, so do their build systems — and the decisions around how to scale them. This panel brings together engineers who’ve migrated (or decided not) to new systems like Bazel, navigated polyglot codebases, and built resilient tooling strategies under real-world constraints. Topics We’ll Explore: * The trade-offs of migrating to Bazel, Buck, or other modern build systems — and why some teams chose not to. * Hidden costs, cultural impacts, and technical debt from tooling transitions. * Strategies for managing cross-platform builds in Kotlin Multiplatform and polyglot environments. * Balancing build performance with developer experience in large-scale codebases. * If we had to do it all over again: lessons learned from build system overhauls.

This session explores the development of an experimental amd potential future handwriting recognition feature for The New York Times Crossword app, on the New York Times Games Android App. We'll discuss the transformation of crossword squares into interactive "SketchBoxes" that capture user input, the challenges of determining input completion timing, and the preprocessing steps like downscaling and binarizing user-drawn characters. The talk will dive into the selection and training of a deep convolutional neural network (Deep-CNN) using augmented datasets to handle diverse handwriting styles, and the integration of the TensorFlow Lite model into the app for on-device inference. Key Takeaways & Learning Points: * Learn how to create responsive interfaces that accurately capture and process user handwriting. * Understand strategies to determine when a user has completed writing a character, balancing responsiveness and accuracy. * Explore methods for normalizing and preparing diverse handwriting inputs for machine learning models. Training Deep-CNNs with augmented datasets * Gain insights into enhancing model accuracy by expanding training data to include varied handwriting samples. Integrating machine learning models on-device with TensorFlow Lite * Discover best practices for deploying efficient ML models within mobile applications. As a Senior Android Engineer on The New York Times Games team, I led the exploration of this handwriting recognition work during MakerWeek 2023. My work involved designing the SketchBox component, implementing input handling mechanisms, preprocessing data, training the Deep-CNN model, and integrating it into the app using TensorFlow Lite. I have about 11 years of experience in Android development. Keywords: Handwriting recognition, machine learning, Android development, TensorFlow Lite, convolutional neural networks, on-device inference, data preprocessing, user input handling. This work has been published in Nieman Lab: https://www.niemanlab.org/2024/01/how-the-new-york-times-is-building-experimental-handwriting-recognition-for-its-crosswords-app/ And the New York Times: https://open.nytimes.com/experimenting-with-handwriting-recognition-for-new-york-times-crossword-a78e08fec08f

A strong engineering culture is crucial for mobile teams to scale efficiently, retain top talent, and drive innovation. This roundtable will explore strategies for fostering an adaptive, inclusive, and high-performing engineering culture across remote, hybrid, and in-person teams. What are the most effective ways to document, spread, and reinforce engineering culture in mobile teams? How do mentorship, knowledge sharing, and in-person events contribute to a strong culture? What common pitfalls can erode engineering culture, and how can leaders prevent them? How does engineering culture evolve over time, and what leadership actions sustain it? What metrics or signals indicate a thriving vs. struggling engineering culture?

A strong engineering culture is crucial for mobile teams to scale efficiently, retain top talent, and drive innovation. This roundtable will explore strategies for fostering an adaptive, inclusive, and high-performing engineering culture across remote, hybrid, and in-person teams. > What are the most effective ways to document, spread, and reinforce engineering culture in mobile teams? > How do mentorship, knowledge sharing, and in-person events contribute to a strong culture? > What common pitfalls can erode engineering culture, and how can leaders prevent them? > How does engineering culture evolve over time, and what leadership actions sustain it? > What metrics or signals indicate a thriving vs. struggling engineering culture?

What if you built your Android app… without the Android Gradle Plugin? In this talk, we’ll explore how to demystify the Android build process by replacing AGP with a custom, minimal Gradle plugin. From compiling Java/Kotlin sources to invoking AAPT2, D8, and signing your APK — we’ll peel back the layers and rebuild the pipeline from scratch. You’ll learn how Android’s build tools actually work under the hood, how to wire them together with plain Gradle tasks, and why doing it yourself might just be the best way to understand the system you use every day. If you're just used to copy pasting the android gradle plugin extension into your projects, come see what AGP really does for you. By understanding it more in depth you'll walk away being able to better debug and modify your builds, increase your productivity, and level up as an Android developer.

Join us as we discuss how enterprise mobile teams can achieve world-class Android app quality using an AI-powered mobile observability platform. Designed specifically for mobile environments, this platform proactively identifies performance and stability issues, enabling teams to resolve problems before they affect end-users. You'll gain insights into how advanced AI-driven observability enhances app performance, boosts user engagement, and delivers measurable business value.

A well-constructed design library connects design and feature teams in a meaningful and effective way. It is flexible to accommodate different designs, while continuing to maintain its own structure. A design system should have a strong management system for both content and UI. It is also a place where accessibility and security can be addressed from the start, saving time across all feature teams. In this talk, we will provide tips and guidelines to architect a design library, enabling feature work to skip local traffic and take the highway to production!

Compose Multiplatform, the declarative framework by JetBrains for building shared UIs, is now stable and production-ready on iOS – so it’s time to start building! In this talk, you will get an overview of the technology, and see what we’ve done to get to the stable release. This includes the evolution of our APIs, under-the-hood changes, and new tooling that we’re premiering for building Compose Multiplatform apps in your favorite development environments, IntelliJ IDEA and Android Studio. You’ll see that there’s a rich ecosystem available for you that has already grown to cover all major areas of app development. Putting it all together, you’ll see how Compose Multiplatform enables you to write production-grade apps on iOS and Android while reusing much of the knowledge you already have – and you’ll also get some insights into what we have planned next in the journey of Compose Multiplatform, on iOS and beyond.

Coroutines are an important tool in the Android developer’s toolbox. We use 'em to background our tasks, to parallelize our work, and to gracefully cancel operations. This is not a talk about that reasonable coroutines use. Instead, we’ll do unreasonable, forbidden things. We’ll study the implementation details of coroutines, scopes, and contexts. Once that foundation is established, we’ll start ‘thinking in coroutines’ and break our brains a bit! We’ll cover: 💣 Making I/O slower with `suspend` 💣 Turning code inside-out 💣 Using reflection with coroutines 💣 Treating the user as a function If you're willing to suspend disbelief, this talk is for you.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. With Kotlin Multiplatform (KMP) and Flutter proving their long-term viability, mobile leaders must navigate the intersection of cross-platform and native development. This session will analyze the strengths and limitations of cross-platform approaches and provide guidance on structuring mobile projects to leverage both paradigms effectively. > How can cross-platform and native development coexist within the same project or company? > What are the primary advantages and trade-offs of cross-platform solutions compared to native? > What types of apps or features benefit most from a cross-platform approach? > How have KMP and Flutter evolved beyond past expectations, and what does that mean for long-term strategy?

The Jetpack Compose runtime and compiler together form the driving force of your composable functions’ execution and recomposition. This talk will unpack the black box of this duo and examine what magic is actually happening under the hood. Together, we will walk through a real-world example of a Composable function as it embarks on a journey through its initial composition and its first recomposition. In this talk, you will learn about the compiler’s role in transforming your composable function bodies, how the snapshot system invalidates your composition, how the runtime computes and applies the changes of a recomposition, and what a SlotTable is. Together, this knowledge will help make Compose feel less like magic and let you make more informed decisions about how to design your composable functions with performance in mind.

If you're comfortable with Jetpack Compose and its out-of-the-box components, another essential tool is the ability to create custom Compose layouts. This ability is easier to achieve than with the View system; it only requires extending a basic understanding of composition and its phases and can become a simple solution to more complicated layouts. From there, you can customize your layouts even further with custom modifiers and sub-composition to take deeper control of the composition and layout, making them powerful, flexible Composables. In this session, we'll review the basics of building a custom layout and then dive deeper into when and how to use sub-composition to take fine-grain control of your layout's contents and phases. We will also look into designing parameters and modifiers to provide flexibility and further customization.

In this talk I will share learnings from over a year spent hacking around in Compose UI to faithfully reimplement some of Trello’s View-based drag and drop interactions and rolling it out to our millions of users. In this talk we will discuss: Creating a custom drag and drop system using a pointerInput and the graphicsLayer modifier. Implementing a more “out of the box” solution with dragAndDropSource and dragAndDropTarget modifiers. The relative merits and pitfalls of each of these approaches. Managing state, making it look pretty, pesky edge cases, and much more!

LLDB debugging of Kotlin/Native is quite different from debugging Kotlin/JVM in IntelliJ IDEA. While Kotlin/Native debugging is limited, there's a lot hidden behind LLDB commands. In this talk, we'll look at what commands LLDB offers us for more effective debugging sessions. We'll also explore Kotlin/Native binaries and the symbols contained in them. Learn how to debug your Kotlin Native code and gain deeper insight into the world of native and binaries.

Calling All Aspiring Space Adventurers: Join the Elite Crew of the USS Singleton (the Federation's greatest explorer class vessel) Today! Embark on the thrilling adventure of a lifetime with the intrepid crew of the Singleton, as you navigate an uncharted (possibly dangerous) galaxy, where mastering Regex is not just an option—it's a matter of life-or-death! During your travels you'll uncover; not only a deep understanding of Regex itself (from basics to advanced), but also how to wield Kotlin to conquer any pattern matching challenge you face, equipping you with invaluable lifelong regex power! If that excites you, then signing up to the legendary personnel of the USS Singleton is for you! Here are just a few of the Benefits of the Job: * Properly learn Regex - From Amateur to Professional, so that you can actually put the knowledge to use! * Learn Kotlin APIs to work with Regex * Explore the vast cosmos & become an Intergalactic Hero having your name sung through the ages! (...possibly) Due to § 213-B:USSF Mandatory disclosure of hazardous workplaces; we must add: Possible “Challenges” of the role: * Ship may crash, leaving the crew stranded on an alien world * Possible loss of sanity and/or limbs * High chance of death. …But no need to worry, with the Captain & the crew of the USS Singleton, you are in very safe hands…So, what are you waiting for? Become a fabled starfarer today and unlock the secrets of Regex… ... Before it’s too late…

Jetpack Compose separates UI into small parts, yet it ties ViewModel lifecycles only to Activities or Fragments. This causes data to outlive its associated UI or be reused inappropriately. We present a fine-grained scoping solution that attaches a dedicated Lifecycle and ViewModelStore to a composable level. By the use of a custom Kotlin Compiler Plugin, generate the necessary code to create and clear the scope automatically. This approach cuts boilerplate code and ensures that data is managed exactly when a composable appears or disappears, offering precise control over UI state in Compose apps.

Growing an Android team from a handful of developers to 50+ without imploding requires more than just good intentions—it demands architecture, automation, and guardrails that make the right decisions inevitable. At Square, we’ve built a mobile codebase that enables teams to collaborate efficiently, share components like Lego blocks, and avoid stepping on each other’s toes—even in a 5M+ line monorepo with 100 Android ICs actively contributing everyday. But you don’t need to be at Square’s scale to benefit. If your team is 10+ and growing, the challenges of coordination, consistency, and performance creep up fast. This talk will equip you with actionable strategies you can start implementing today to keep your engineering team productive over time. In this talk, you’ll learn how we: * Use a consistent UI framework to enforce strict yet flexible contracts, making UI and business logic highly composable. * Slash build times by modularizing code, separating interfaces from implementations, and structuring dependencies to minimize build times. * Ensure consistency at scale with custom lint rules and CI checks that enforce best practices. You’ll see real-world CI checks from Square that you can apply to your own projects—preventing dependency misuse, enforcing modularization, and maintaining architecture standards—to help engineers "fall into the pit of success" without constant oversight. These aren’t just theories—they’re battle-tested strategies that have helped us maintain velocity without sacrificing quality. Of course, it’s not always smooth sailing. I’ll share the challenges we’ve faced, the landmines we’ve hit, and how we’ve had to pivot along the way—so you can avoid the same pitfalls.

Dependency Injection (DI) plays a key role in building scalable software projects. The Android community has spent the last decade experimenting and iterating on DI approaches primarily focused on the benefits of facilitating testing and building more modular apps. If you weren't in the industry during that experimentation and iteration it can be easy to miss how we got to where we are today. In this talk, we're going back to basics! We're going to look at Dependency Injection, to help you understand the concepts behind the pattern, irrespective of which library, if any, you use to implement it. We'll look at the basic approaches to dependency substitution, see what problems DI can help solve, and learn how to make our own DI implementation.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. Scaling an app under rapid growth presents significant engineering and business challenges. Attendees will learn strategies for handling system scalability, maintaining reliability, and making critical engineering decisions under pressure. > What are the challenges of scaling systems rapidly? > What best practices exist for re-architecting apps under pressure? > How can engineering leaders balance business goals with engineering constraints? > What strategies exist for building resilient and scalable architectures?

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. As mobile teams scale, specialization becomes essential, but striking the right balance between deep expertise and cross-functional flexibility is challenging. This session will explore different specialization paths in mobile engineering and how leaders can structure teams, hiring, and career growth to maximize both innovation and long-term success. > What are the key specialization tracks in mobile engineering? > How can engineering leaders ensure specialization doesn’t create silos within a mobile org? > What strategies help balance hiring and training across specialized and generalist roles? > How does a specialist career track impact long-term growth, leadership opportunities, and adaptability? > What are best practices for integrating specialists into cross-functional product teams?

AI coding tools have had some of the most wild hype to ever emerge from Silicon Valley, which is no small feat. From the native mobile world, this has all seemed very distant, and easy to pass off as just hype. But, native mobile is mostly locked to specific IDEs, largely untouched by these tools until recently. There is a lot of hype, but there is a lot of reality, and it goes way beyond chat and verbose auto-complete. Native mobile is also unique, with separate apps doing basically the same things. That makes native mobile both largely overlooked, and uniquely positioned to benefit from these tools. Technical topics we'll cover: * The state of models today, and where they might go in the future * Agent tools * What you can do with AI beyond "it helps write tests" * The rapid rise of open-source tools directly competing with the commercial "household names" Moblie topics: * AI is amazing at "porting code". Making Swift from Kotlin and vice-versa * How that might impact native dev * How that might change the cross-platform vs native calculus * AI tools enable productive dev in unfamiliar languages and ecosystems (and how that should impact "platform silos") We've been integrating AI tools at all levels of work, and recently completed an iOS to Android port, mostly automated, in a fraction of the time the client estimated the project to take. Lots of hype, but lots of real utility. Far from replacing developers, developers can get the most out of them. As time goes on, they will be as essential as IDEs and source control. And it's all coming to the mobile ecosystem very soon.

This session dives into the technical application of a mobile AI Suite SDK for integrating Vision AI into enterprise Android solutions. Attendees will explore the architecture and APIs for deploying on-device machine learning and computer vision, with a focus on performance, latency, and real-time data processing. Topics include model integration, camera optimization for structured data capture, and advanced design patterns for robust, scalable AI implementations. The session will also preview upcoming SDK features relevant to future-proofing AI applications.

What if you could *see* exactly what led to a crash or non-fatal error? In this talk, we’ll dive into the mechanics of mobile session replay and its impact on how developers debug and optimize Android apps. You'll get a hands-on look at how replay helps you: - Understand exactly what production users experienced before an error or crash - Quickly diagnose issues without needing endless custom logs We’ll also give a quick overview of Sentry’s mobile monitoring platform and how Session Replay fits into a faster, smarter debugging workflow. With Session Replay, developers gain the context they need to not just fix issues — but truly understand and improve the mobile user experience.

Last year we asked ourselves a question. One that most Android engineers avoid whispering aloud: Are Instant Apps still a thing? It turns out that Google officially said no! Instant Apps are fascinating because they offer possibilities outside of what Google originally engineered them for. Benoît (Cash App) and Cyril (Amo), both of us shipped an Instant App this year for different use cases and different implementations. The restrictions required to publish an Instant App encourage dynamic, lean and performant architectures. Savoir-faire which stays relevant even outside the context of Instant Apps. After hovering briefly over the state of Instant Apps, we’ll share how we built and shipped our projects. From development quirks to publishing oddities, we’ll highlight what worked, what didn’t, and why Instant Apps might have deserved a second look.

Stoic - https://github.com/square/stoic - is a tool for running code inside an Android process without modifying its APK. This talk will give an overview of Stoic's architecture and examples of things you can do with it.

Kotlin multiplatform is a great way to share new and existing Kotlin code with other platforms. But what about non-Kotlin code? Turns out Kotlin multiplatform can also be a great way to share code from other languages such as Swift, Rust, Zig, C, and more. This talk will show how to adapt code from these other languages into KMP, the restrictions and considerations when doing so, and look at some existing libraries which are doing this today.

Have a chat with Developer Advocates from JetBrains about anything Kotlin related on your mind. Language evolution, tooling, development practices, Kotlin Multiplatform and Compose Multiplatform... We're here for all of it!

Sometimes you think you know coroutines, and then after a while, you’re like, “Wait, do I really know coroutines?” Inspired by the O’Reilly book _Programming Android with Kotlin_ and the upcoming new Droidcon eBook _Mastering Kotlin Coroutines: From Basics to Advanced _, this talk strengthens everyday coroutine understanding through playful explorations. You don't have to master coroutines to get started and be productive with coroutines. But when you walk out of this talk, you have deep understanding of coroutine mechanics and what tools can help you debug coroutine behavior. You might be in the beginning stages of learning Kotlin. Or maybe you’ve been using coroutines for a while and want to brush up, or maybe you're a little burned from other talks. Either way, you'll be looking at coroutines a little differently by the end of this session!

Kotlin native allows you to target multiple platforms. In this talk, we’ll do a deep dive on the architecture of the compiler. The compiler consists of a pipeline that transforms Kotlin Intermediate Representation IR to LLVM IR. It also allows you to create a binary, library or framework. We’ll explore the phases executed in the pipeline that run the frontend, backend and linking process. I’ll do a walkthrough of the compiler with live coding. I’ll share how to get metrics on the performance of each phase in the pipeline of the compiler. I’ll share undocumented compiler configurations to get a view of LLVM transformation. Lastly, I’ll briefly share the inner workings of Kotlin and Swift export. By the end of this talk, you should have a good foundational understanding of Kotlin Native internals.

Paparazzi 2.0 development has been underway since last year's Droidcon NYC: In this session, we'll discuss: * what APIs the 2.0 release will offer * how to have more control with animation snapshots with a proposed keyframe and touch gestures API * how to tackle fidelity issues between real devices and layoutlib using diffing algorithms * ...and more! We'll also give a demo of these 2.0 features, as well as why we're excited about it and you should be too!

From generating Moshi JSON adapters, to generating dependency injection code with Dagger, to generating database code with Room, most Android developers will interact with a code generator at some point throughout their career. However, the inner workings of these tools are opaque, and writing one can be even more daunting. This talk will walk through a simple example of generating log tags using Kotlin symbol processing. It will aim to make understanding code generators more accessible and to inspire listeners to solve problems with code generation. Key Takeaways: - A short history of code generation on the JVM. - How to identify whether a problem is appropriately solved using metaprogramming techniques. - How to set up a KSP project. - How to use KSP APIs to process code as input and use KotlinPoet to generate code as output. - Where code generation fits in a world where we generate code with LLMs.

Engineering teams often rely on traditional metrics, but are these truly driving better outcomes? This session examines conventional measurement approaches and explores how to combine performance measurement with positive developer experience. Attendees will learn how to measure team effectiveness in a way that fosters engagement, alignment, and long-term success. •What are the limitations of traditional engineering metrics? •How can KPIs be balanced with developer experience? •What frameworks exist for measuring team effectiveness? •What strategies exist for improving alignment and engagement? •What actionable insights can be used to drive high-performance engineering teams?

Exploring the basics of the new Jetpack Navigation 3 Compose library with the breakdown of the API and walking through all the new exciting features. Following the basics, we’ll take an in-depth exploration of how to architect navigation for scalability in large, evolving applications. We'll discuss effective patterns and practices, demonstrating how techniques like Dependency Injection facilitate integration and maintainability for production level applications.

Dependency Injection remains a cornerstone of scalable Android architecture—but as the platform evolves, so do the tools and patterns we rely on. This panel brings together DI experts to discuss the current and future state of DI in Android, from Google’s Hilt and Kotlin-first Koin to community-driven frameworks like Dagger, Anvil, and Metro. We’ll explore real-world lessons and technical insights across topics such as: What are the key strengths and weaknesses of current DI frameworks, and how should teams choose the right tool for their architecture and scale? What are the tradeoffs of using DI at scale, and where do most frameworks begin to show their limitations? How can teams effectively manage complexity, performance, and maintainability as their DI setup grows? Can Dependency Injection be used for more than just wiring services and repositories? What are some unconventional or creative use cases, and how well do frameworks support them? What are effective strategies for migrating between DI frameworks, especially in large codebases? With Kotlin Multiplatform adoption increasing, how can DI be applied across shared and platform-specific code? What are the challenges of building and maintaining multiplatform DI solutions, and what opportunities does this unlock for cross-platform architecture? What goes into designing and building a DI framework from the ground up? What technical decisions, architectural patterns, and developer experience considerations must be addressed—and where do current solutions still fall short?

Mobile engineers have a hard time having high confidence when simple changes can have cascading consequences. The UI tests meant to provide confidence are slow, brittle, and generally expensive to run. Product owners and designers have a tough time dogfooding mobile apps on both platforms. Accessibility audits require experts in mobile accessibility - and after 15 years we’re still applying WCAG once a quarter. Have I got something for all of you. AutoMobile is a comprehensive set of tools that enables AI agents to interact with mobile devices and comes with automated test authoring, AI supported test recovery, and drop in support for test execution in Android Studio and CI. I'll be walking through some of the development journey and system design with live demos to illustrate the capabilities along the way. What You'll Take Away: • How to build an MCP server designed for high value outcomes. • How to use AutoMobile in your development workflow to improve product usability, accessibility, and more. • How tools like this change everything and there are only bigger changes coming.

In this talk we'll explore some of the experimental and upcoming language features in Kotlin. Kotlin is a fast-evolving language and there are a number of KEEPs that explain new features that the Kotlin community would like to added to the language. Many of these features are already available via experimental compiler flags. In this talk we'll explore some of these exciting new features so that you know what to expect in the next 1-3 years as Kotlin continues to evolve.

Getting users to pay for your app is an art and a science. Let’s look at the current state of pricing strategies and different approaches to free trials. I’ll share some of the most recent market trends and share real-world lessons from successful apps. You’ll gain insights into current market trends and how user behavior is shaping monetization tactics. Whether you’re launching a new app or optimizing an existing one, this talk will provide actionable takeaways to help you price with confidence.

Discover how the Model Context Protocol (MCP) connects AI to the real world. We'll explore the Model Context Protocol using the Kotlin SDK letting an Agent control Android devices with ADB! We’ll live code a new ADB tool and demo how AI Agents and the MCP can automate tedious device tasks, like setting up device permissions, streamlining your Android workflow. You’ll leave this talk understanding the Model Context Protocol, its Kotlin SDK, and be ready to build your own AI-driven integrations!

Traditional Android dialogs are hard to test, easy to leak, and painful to customize — and in a world of Compose-first apps, they’re overdue for an upgrade. At Block, we built a fully Compose-driven overlay system that eliminates dialog fragments, supports modern soft input behavior, enables screenshot testing, and has shipped to production in one of our core apps. In this talk, I’ll walk through how we built it, the lessons learned, and how your team can adopt or extend this system (including our plans to open source it). Whether you're working on popovers, full modals, or anchored dialogs — this talk is for you.

In this talk, we will show a brand new DI procedure: a zero-intermediation architecture that directly links dependency producers and consumers through bytecode modification during Android Gradle Plugin (AGP) transform stage. By rewriting property delegations at the bytecode level, our approach compiles dependency declarations into direct field assignments functionally equivalent to manual implementation, achieving runtime performance and near-identical package size.

SDUI is a software architectural paradigm that centralizes UI decision making on the server, offering a dynamic and adaptive UI experience across all platforms, with one codebase. This talk discusses the value of the promise of “one codebase, deployed to all apps across different platforms” and how SDUI patterns could be the future of application rendering. In this talk we dive into - Reasons for the emergence of SDUI as a paradigm - Fundamental components of a successful SDUI system - Case studies of popular apps using this pattern - Recommendations for developers on when to choose SDUI over traditional native per-platform client-side rendering Key takeaways and learning points - Being able to make the trade-off between SDUI and client-driven rendering paradigms - Awareness of the fundamental architecture pattern for SDUI - How to get started with SDUI for your app

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. AI coding assistants have been hyped as game-changers for software engineering, but how effective are they in practice? This session provides a reality check on current AI coding tools, analyzing what works, what doesn’t, and how these tools impact software development workflows. You'll get a chance to discuss best practices, challenges, and the future trajectory of GenAI in software development with your peers and examine: > What is the current state of AI coding assistants? >How are AI coding assistants improving developer productivity? > What AI tools are effective for software development today, which ones are disappointing? > What are the future trends and implications of AI-driven software development? > What are the implications for cross-platform development?

Application architecture can either die perfect, or live long enough to be a huge, risky problem to solve. If you’re unlucky, that risky problem might require you to add new data boundaries in memory, persistent storage, and even in downloadable dynamic feature modules. It is possible to do it safely, though, using structured concurrency, dependency injection, and a carefully designed tenancy model. By using modern tools and proven legacy code techniques, even a big migration like this is possible without interrupting engineers with tedious migration work, or customers with forced sign outs.

At Instagram, we serve billions of users worldwide, making our Android app one of the largest and most actively developed in the world. With thousands of code changes every day and weekly/biweekly releases, maintaining performance at scale is a constant challenge. Among these challenges, memory management stands out as critical—unchecked memory issues like leaks, oversized JVM objects, or native memory bloat can trigger OutOfMemory (OOM) crashes, Application Not Responding (ANR) errors, and other reliability problems that directly degrade user experience. Our data shows a clear correlation between memory inefficiencies and user engagement, making optimization a key lever for success. In this session, we’ll share how we’ve operationalized memory management at Instagram’s scale across core surfaces like Stories, Reels, Feed, and Messenger. We’ll dive into: Memory issue categorization and pipelines: How we classify and prioritize leaks, native memory growth, and JVM bloat using automated tooling. Triaging at scale: Strategies to identify root causes efficiently across a rapidly evolving codebase, including OOM crash analysis. Dynamic, memory-aware components: Techniques to make features adaptive to memory constraints (e.g., gracefully degrading resource-heavy features during low-memory conditions). Automated testing: How we integrate memory checks into CI/CD to catch regressions before they ship. Lessons from the trenches: Real-world examples of memory issues, including high-profile OOM incidents, and how we resolved them. Join us to learn how we balance rapid iteration with stability, ensuring Instagram remains performant even as we push the boundaries of what’s possible on Android.

Gain insights from engineering leaders about how effectively managing technical debt in their codebases. We'll discuss approaches to prioritization, refactoring, and establishing healthy development practices to ensure long-term maintainability and team velocity. We'll discuss questions like: >What are effective methods for identifying and quantifying technical debt in projects to make informed prioritization decisions? >How can engineering leaders effectively communicate the business impact of technical debt to product teams and secure resources for necessary refactoring efforts? >What are proven strategies and processes for preventing the accumulation of technical debt in mobile development workflows, considering the nuances of both native Android and cross-platform frameworks? >Beyond dedicated refactoring sprints, what are some incremental approaches and engineering practices that can be integrated into daily development to continuously address technical debt and maintain codebase health?

Building effective development teams hinges on prioritizing the developer experience. Poor tooling and inadequate support lead to cumbersome builds and inefficient workflows, creating friction that slows engineers and hinders their ability to deliver value. Join this peer discussion to share and discover practical strategies for boosting developer velocity and satisfaction. > How can we effectively measure the developer experience to pinpoint specific friction points that negatively impact team velocity and satisfaction? > What tools or strategies effectively boost knowledge transfer, reduce cognitive load, and accelerate onboarding? > What are your team's biggest DX pain points with builds, IDE, or CI, and what proven leadership tactics address them? > Where does your team experience the most friction day-to-day (e.g., with builds, IDEs, CI/CD, inefficient workflows)? What practical leadership tactics or tooling improvements have successfully addressed these pain points? > How can engineering leaders effectively quantify the impact of DX improvements on velocity, satisfaction, or overall value delivery to justify necessary investments to stakeholders?

To raise awareness about the increasing sophistication of mobile app attacks, particularly those leveraging AI, and to provide actionable insights into effective protection strategies. What to expect - Example of attacks that are been observed in the wild - Current Protection Approach Key Take Away - Considerations on how to combat new AI driven attacks

In this keynote, you'll hear from well-known Android experts about their hot-takes, predictions, wishes and advice about how they expect the Android ecosystem to change and how to best prepare for that future. Join us as they answer the question: Where do you see Android Development in three years, and how do you think developers should prepare for that future? After all experts are done making their pitch for the future...its your turn to ask the questions in a rapid-fire Q&A format.

As mobile and web applications scale, maintaining visual consistency across platforms becomes a major challenge. A well-structured design system, powered by design tokens, ensures scalability, consistency and flexibility. In this talk, you will learn about core tokens and component tokens to create the building blocks of a scalable design system. We’ll use Style Dictionary to generate platform-specific code from tokens and guarantee a unified design language across platforms. A live demo will showcase how tokens sync from Figma and derive flexible theming and component styling in an Android app. #ui/ux, #design, #designSystems, #designTokens, #theming, #styleDictionary, #figma, #cross-Platform, #scalability, #goose

In this lightning talk, we’ll highlight the importance of monitoring main thread performance. We’ll demonstrate how we enhanced our mobile observability tools at Bitdrift by leveraging JankStats, a useful library for identifying janky frames in your app. We'll also explore the main challenges and key learnings we encountered during our integration of JankStats, along with tips on how to avoid common pitfalls.

Mobile application security, especially time spent on applying it, is often seen as a necessary evil. Security tools that are actually effective require additional configuration efforts, and that doesn't always line up with the skillset needed to build great mobile apps. To optimize apps for performance, another set of manual processes is required to configure the build tools. On top of that, even when developers manage to configure these tools, app security and performance improvements are not always guaranteed nor noticeable by the end users. What if the skillset required for using these protection tools would overlap with regular app development skills? What if using these tools would actually remove some of the manual work required to optimise your application and save you time? In this talk we will show how this is now a reality! Attendees will have the following take-aways: - A brief overview of advanced R8 optimisation features and the effort that goes into using them correctly. - Insight in the concept of profile based optimisations, its shared benefits for application protection and the amount of manual work it can prevent. - A demo show-casing how easy it can be to run through a profile based configuration step. - Practical and concrete examples of the non-security related benefits of a profile based configuration approach, e.g. automatic R8 baseline profiles, auto-generated keep-rules tailored to your code, order files to speed up native code loading, additional app size reductions beyond R8

At Uber’s scale, guaranteeing an always-green mainline while processing hundreds of changes per hour in the Android monorepo, which supports multiple business-critical apps, presents significant challenges, such as growing queues of pending changes, frequent conflicts, build failures, and unacceptable land times. These bottlenecks slow down development, negatively impact developer productivity and sentiment, and make Continuous Integration of changes increasingly difficult. In this talk, I’ll explore the design and evolution of MergeQueue—Uber’s innovative CI scheduling system that ensures mainline stability and production readiness for every commit. By harnessing speculative validation, build-time and change success predictions, and advanced conflict resolution strategies, MergeQueue delivers unmatched efficiency. For Android, It has reduced CI resource usage by approximately 53%, CPU usage by 44%, and P95 waiting times by 37%. These optimizations not only eliminate CI bottlenecks but also enable thousands of engineers to ship code rapidly and reliably, ensuring every commit is production-ready. Key Learnings: 1) Scaling CI for High-Commit Velocity – Learn how to design and manage CI systems that process hundreds or even thousands of changes per hour across monorepos while ensuring a green mainline and production-ready commits. 2) Optimizing CI Efficiency – Understand how speculative validation, build-time predictions, and change success predictions significantly reduce CI resource usage, CPU consumption, and waiting times. 3) Conflict Resolution in CI: Discover strategies for handling frequent conflicts, build failures, and long land times, ensuring smooth and efficient Continuous Integration at scale. 4) Best Practices for Scalable Developer Productivity – Gain actionable insights on designing and implementing CI/CD systems that minimize bottlenecks, improve developer experience, and maximize efficiency in large-scale engineering environments.

Innovation, inspiration and economies of scale are increasingly pushing apps to become more adaptive; Jetpack Compose's declarative API makes it a perfect choice to meet the dynamic requirements of building adaptive apps for multiple form factors and platforms. How then, does one go architecting and building the UI layer for adaptive Jetpack Compose multiplatform apps without compromising the developer or user experience on any form factor, or platform? This talk will: Present a case study of a real world production scale social media Compose multiplatform app (an open source bluesky client) targeting, phones, tablets and desktops, and the architecture principles in the UI layer used to build it. Specifically, it covers: Business Logic in the UI Layer * State production for adaptive apps How is adaptive conditional logic handled? * Navigation for adaptive apps * What is an adaptive pane? * What can change within a pane? * How do panes change with navigation? UI Logic in the UI Layer * How are persistent UI elements like app bars and FABs managed between device configurations and platforms? What panes own the navigation UI elements like the nav rail? * How do shared element transitions work in adaptive apps? * How are intensive system resources like video players shared?

This session explores how mobile teams can leverage their existing skills to create compelling XR experiences. With Android XR out and Project Moohan's release right around the corner. This is your opportunity to discover how mobile staples might be the industry's springboard into spatial computing, what challenges to expect, and how to prepare yourself and your apps for an increasingly cross-reality ecosystem. What is the current market landscape for XR on mobile platforms, and what trends or opportunities are projected for the next 2–3 years? What is the most common misconception among mobile designers and developers when considering a pivot to XR development, and how can businesses address it? What are the top tools, SDKs, and platforms that mobile developers should be looking at for XR projects? What unique design and UX challenges arise when building XR experiences for mobile devices? How can mobile development teams transition into XR development efficiently, leveraging existing skills and resources to minimize costs and learning curves? What's the most annoying parts about XR development compared to mobile? What are the most lovable parts about XR development compared to mobile? What unique advantages does XR development offer over mobile development that businesses can capitalize on to drive innovation or engagement? How do you see monetization and business models evolving in the mobile XR space?

Android isn't going away, but your job might be. Your job, as it is today, is in danger. With the rapid changes in AI to allow more work to be done by a single developer, more technical and prototyping work done by product and management, pressure like we have never seen to do more with less staff, and the ever-increasing business, consumer, and leadership skills shifted-left onto you as a dev - it can feel impossible to stay relevant or feel capable. Then add KMP being the future of application development in ways that Flutter and React never could be as mobile development reaches market maturity, and you have some choices you need to make now. We can do this. You can do this. Together, we are going to talk about how to enact real change to provide value in your job, focus on your goals, architecture built for tomorrow, and balance adding technologies so that you are ready to maximize your impact or even just stay afloat.