Vinted is Fully Composed
We finally did it: every single product screen in the Vinted Android app is now Jetpack Compose. Yes, you read that right: a 15-year-old codebase spanning more than 300 screens was migrated to Compose in 18 months; all while dozens of developers continued shipping product features every single day.
Here is our story, which we hope proves that a full-scale legacy migration on a massive, moving codebase really is possible.
Meet ProJet
Before writing any code, we did the most important thing: the name.
The initiative was deliberately not called Jetpack Compose migration because it covered far more than that: testing, accessibility, screen architecture, and communication patterns. We needed a framework with a memorable name. The winner was ProJet: Project + Jetpack. Short, easy to remember, and easy to explain (well, mostly*). Bonus point: it doubled as the codename for the entire migration initiative.
*Except to our non-Android colleagues, for whom “projet” is just… a project.
ProJet is our thin framework on top of Compose. ProJet allowed us to keep the screen patterns we already had and focus purely on the Compose migration. From day one, it also provided first-class support for integration and snapshot testing.
For us, that meant:
- A base fragment that hosts a Compose screen. Yes, we kept Fragments deliberately. They now serve purely as a thin presentation layer: navigation, results, and lifecycle events, acting as entry points to Composables. This lets us migrate screen by screen without having to rewrite navigation or existing plumbing upfront.
- A dual-stack design system. Our design system, Bloom, supported both legacy Views and Compose with pixel-perfect visual parity. We rewrote around 75 components in Compose so that every building block was ready in both worlds before we migrated a single product screen.
- Snapshot testing support. We connected Compose previews directly to Paparazzi using a custom
@PreviewSnapshotannotation (powered by ComposablePreviewScanner). Since legacy XML had no golden images to diff against, writing a preview gave us a snapshot test almost for free. Also a nice bonus, PR reviewers could visually inspect every screen state directly in the pull request before merging. - A coverage gate in CI. Every ProJet screen class must have test coverage, enforced per screen. Migrating a screen and covering it with tests became a single, indivisible task.
And this is a whole ProJet screen, more or less in its entirety:
@ContributesFragment
class CheckoutFragment @Inject constructor(
private val viewModelFactory: InjectingViewModelFactory<CheckoutViewModel>,
) : BaseProJetUiFragment() {
private val viewModel by viewModels { viewModelFactory.create(this) }
@Composable
override fun OnCreateProJetView() {
val state by viewModel.screenState.collectAsStateWithLifecycle()
CheckoutScreen(
state = state,
onPay = viewModel::onPay,
...
)
}
}
@Composable
fun CheckoutScreen(...)
The entry point is just that single @Composable override, and that is it. The base fragment quietly brings the Bloom theme, toolbar, screen tracking, progress handling, app messages, and accessibility plumbing. Each screen comes with a companion preview composable:
@PreviewLightDark //renders in both themes
@PreviewSnapshot //turns into paparazzi snapshots
@Composable
private fun CheckoutScreenPreview() {
Preview {
CheckoutScreen(
state = CheckoutState(payButtonEnabled = true),
onPay = {},
)
}
}
We compare Paparazzi snapshots against golden images in CI. This has already caught countless subtle regressions from seemingly unrelated changes, like a dependency bump or a foundation refactor silently breaking a screen on the other side of the app.
Why a full migration?
Our app architecture could easily support legacy and ProJet screens living side by side indefinitely. So why bother migrating everything? Glad you asked! Living in two worlds sounds convenient on paper, but it carries hidden costs.
First comes our design system, Bloom. Bloom is actively evolving with new components across multiple apps. Supporting both XML and Compose meant building, testing, and syncing every component twice, nearly doubling our design system workload.
Then there is the friction many developers faced day-to-day. Whenever an engineer touched a legacy screen, they faced a frustrating dilemma: write new code using deprecated XML, migrate the entire screen on the spot, or stitch together a hybrid using interop. It turns out the hybrid approach got messy fast, and constantly context-switching between two fundamentally opposite UI paradigms slowed everyone down.
Finally, there is the burden of supporting two different testing stacks. Unit tests only verify business logic, but catching visual bugs requires automated snapshot testing. While Compose makes screenshot testing fast and reliable, supporting it across both legacy Views and Compose would have meant maintaining two separate testing frameworks, two CI configurations, and two sets of golden baselines. Committing to a full migration let us skip implementing testing on the legacy system altogether.
As it turned out, we moved at the right time. We made our decision well before Google’s Android announced that Android UI is Compose-first and moved legacy Views and fragments into maintenance mode. By the time that announcement arrived, we were already crossing the finish line.
What we learned along the way
Migrating over 300 screens in a fast-moving production app is far more than just rewriting XML layouts into Compose. It is an organizational challenge. We kicked off with 27 volunteer screens in Q1 2025 to iron out early framework blockers, expanded to pilot teams, and then scaled across every product domain.
Here are the biggest lessons from that journey:
Verification takes longer than writing Compose. When we surveyed our developers after crossing the finish line, the most common answer to “what took the longest?” was not learning Compose. It was proving that the new screen behaved exactly like the old one. Our legacy XML screens had virtually no UI tests, so there was nothing to compare against: parity checking meant reading old code and chasing edge cases by hand. It was tedious work, but the payoff is permanent: every ProJet screen now ships with previews, snapshot tests, and enforced coverage. That verification tax was paid once and for all.
A/B test everything, even “safe” refactors. We treated screen migrations like product changes rather than purely technical cleanups, running over 100 A/B tests on live traffic. We had a firm rule: no migrated screen reached members without a guard—either an A/B test or a feature flag—so we could instantly roll back to the legacy screen if an issue arose. Even when a screen looked visually identical, subtle behavioral regressions still crept in, and this safety net caught them before they could hurt members. Along the way, we even uncovered a bug in Jetpack itself, where hidden tabs kept running in the background and firing unnecessary network calls. We reported it with a fix, which Google’s Android team promptly merged for their next release.
Interop wrappers hide your wins. To let teams work independently, we built temporary bridges (ComposeProxy) so Compose components could live inside XML screens and vice versa. While this enabled incremental migration, interop introduced noticeable performance overhead, especially inside scrolling lists. Because the hybrid layer dragged performance down, the real smoothness and responsiveness of Compose only appeared once screens were 100% migrated and the wrappers were removed.
class BannerProxy : ComposeProxy {
@Composable
override fun Render() { /* banner ui */ }
}
// Embeds the Composable inside a ComposeView with the Bloom theme attached
val bannerView = proJetUiInterop.createComposeView(host = this) {
bannerProxy.Render() //composable
}
containerViewGroup.addView(bannerView)
Do not mix a technical migration with a product redesign. Whenever a screen was a strict 1:1 visual migration, it went smoothly. But trying to save time by combining a screen redesign with the migration consistently led to missed deadlines and endless merge conflicts with the main branch. This is why keeping migrations decoupled is essential; bundling them makes a partially migrated codebase far more costly than it looks.
What the migration bought us
We did not start this migration to move business metrics. We simply wanted a modern UI stack, simpler code, and automated tests we could trust. We expected our A/B tests to confirm no harm and call it a day.
Instead, when we rolled out the pure Compose version of our Homepage, users started interacting noticeably more:
- Clicks per active user: +2.69%
- “Favorite” clicks per active user: +2.10%
Other screens showed the same pattern, with item clicks rising by up to 1%.
Why did a 1:1 technical migration move conversion? Our leading theory comes down to smoother performance and an always-correct UI. Pure Compose screens scroll faster with less jank, and declarative state ensures the UI is always in sync with data. Users feel the difference in speed and reliability, and it shows in their behavior.
Don’t just take our word for it; here is what our engineers announced internally when the results came in:
“For some reason it seems to be bringing more money for the business, so I’d love to make a shameless plug and brag about the newsfeed ProJet migration.”
— Vytautas Narkus, Android engineer
Beyond business metrics, the migration forced a massive spring cleaning across the entire app. On the Homepage alone, the presentation layer code shrank roughly in half (from ~800 lines to ~400 lines) because old workarounds and misplaced logic were untangled along the way. Multiply that across 300+ screens: every single presentation layer in the app got rewritten, reviewed, and covered with automated tests.
Just as importantly, developers simply love writing UI in Kotlin. Eliminating the constant context-switching between static XML tags and Kotlin logic made day-to-day feature work faster, type-safe, and genuinely enjoyable. The feedback from our team says it best:
“No more RecyclerView. Everything lives in one place now: no separate XML layout, no fragment binding, no delegate adapters. Just a composable per list item type.”
— Ramonas Naujavičius, Android engineer
“Screen testing. XML never really allowed it, and now we have it everywhere.”
— Henrikas Smičius, Android engineer
“After months of Compose, going back to XML wasn’t easy. I had started to forget it.”
— Karolis Žiūkas, Android engineer
“State handling is far simpler and more stable than with Views, with fewer workarounds. And testability is better across the board: previews, snapshots, integration, native E2E. A nice side effect: the migration forced us to fix a lot of tech debt in old, messy areas.”
— Arnas Matuolis, Android engineer
Wrapping up
We still have a couple of stubborn XML files in places like our in-app WebView wrapper and video player controls, where rewriting them would bring little practical value. We also deliberately kept Fragments as thin screen hosts as part of the ProJet framework. With Google treating the legacy View system as maintenance mode, Fragments remain the last legacy piece in our UI stack. But that was a conscious, pragmatic trade-off: keeping Fragment navigation let us migrate hundreds of screens without having to re-architect our navigation layer first.
Still, everything that our members or developers touch every day is Compose.
This milestone was a community-wide effort across all of Android engineering at Vinted, made possible by great open-source tools like Jetpack Compose, Paparazzi, and ComposablePreviewScanner.
If your team is staring at a mountain of legacy XML and wondering whether a full migration is feasible: it is. You don’t have to freeze feature delivery, and you don’t have to live in two systems forever.
And if tackling large-scale architectural challenges on a pure Compose codebase sounds like your kind of problem, we’re hiring Android engineers. Come build with us!