Too custom for a no-code builder? Not anymore

TL;DR:
- Your developers build a native view once, and you ship everything around it with a publish. Only a new view or a change to an existing one waits for an app release.
- A custom element can hold any view your app can draw. Lottie animation, the feature teams asked for most, sits next to charts and pickers.
- Custom elements are live with Adapty iOS SDK 4.4, and support for Android and cross-platform SDKs is upcoming. Until then, the same flow shows the fallback you design in the builder.
- Version 1 is one-way: the view shows inside the flow, but the flow can't react to what a user does in it yet.
If you run onboarding at scale, you know the screen you kept out of the builder. It might be a Lottie animation on the welcome screen or a height picker with a cm and ft/in switch. The builder couldn't draw it, so that screen stayed in code, and every change to it waited for a release.
Animation was the request we heard most about the Flow & Paywall Builder. On November 16 we shipped custom elements, which cover animation along with any other view your app can draw.
A custom element is a block on a flow screen that your app fills with its own native view. When the app has no view for it, your users see fallback content you built in the builder.
Teams kept asking how to make their onboarding feel more native and smoother. Now the screens that matter most can use the same views as the rest of the app, so the whole flow feels like one product, and that makes it more engaging.
What can you build with a custom element?
You can put any view your developers build in SwiftUI or UIKit on a flow screen, in onboarding or on a paywall: a Lottie or Rive animation, a chart, a map, a picker. The block sits in the Media group of the Add element panel, and your app decides what renders inside it.
To test how far that goes, our team took the Workout onboarding from the builder's template library and added 10 custom elements to it:
- a Lottie animation
- a height wheel picker that switches between cm and ft/in
- a weight ruler with inertia and haptics
- a BMI calculator with a live gauge
- an animated weight projection chart
- a push notification preview on the permission screen
- activity rings in the style of Apple Fitness
- a native five-star rating
- a wheel of fortune for a paywall discount
- a live counter of people training right now
The demo ran in the iOS simulator with real taps.
Through your app's code, a view can also show what the user told you earlier. In the weight goal chart recipe, the onboarding flow asks for the current and goal weight, and the paywall flow draws the weekly projection as a chart. Your users can drag along it on iOS 17 or later, and on iOS 16 they see the line without the drag.
Who builds what, and what do you ask your developers for?
Your developers build each view once, and you own everything around it.
- You, in the builder: add the block, give it a Type such as
lottie_animationand an ID such aswelcome_wave, set its height, design the fallback and publish. - Your developers, once per view: build the view, return it from a resolver for the same Type and ID, and ship it in an app release.
When a screen with a custom element opens, the Adapty SDK passes the Type and ID to the resolver, which returns the matching view or nothing. Ask your developers for an app-wide resolver, set once before the first flow screen opens. The SDK calls it in every flow, so the same view can appear in new flows and A/B tests without another release.
The brief for your developers fits in a few lines. The app runs Adapty iOS SDK 4.4 or later. Build this view, say the streak ring, for Type lottie_animation and ID streak_ring. Return it from the app-wide resolver. The iOS guide has the code.
Adapty works as the transport here. The SDK places the view and renders the rest of the screen as native UI, while the view's code ships with your app updates.
Which changes to a custom element need an app release?
Only a change to the native view itself needs an app release. The view is part of your app's code, so a new animation or a redesigned picker ships with an app update. Everything around the view ships with a publish, including the fallback and the element's other settings.
| Change | What you do | Your users who haven't updated see |
| New look for an existing view, such as a different animation | Release an app update | The previous view, if their version has it |
| A native view for a new element | Release an app update, add the element, publish the flow | Fallback content |
| An existing view on another screen, in another flow or in an A/B test | Add an element with the same Type and ID, publish the flow. No app update if your app-wide resolver returns the view | The native view, if their version has it |
| A new Type or ID for an element | Release an app update, publish the flow | Fallback content |
| Fallback content and other element settings | Publish the flow | The updated content |
The third row gives you your speed back. Once a view ships in the app, you can drop the same streak ring into a new onboarding variant or an A/B test arm with no developer involved. A flow with a resolver of its own works differently. The weight chart reads onboarding answers through such a resolver, and it replaces the app-wide one in that flow, so your developers route the other views through it.
How do you test a custom element before your users see it?
You test it on a device, in a build of your app that includes the view. The builder canvas and the preview in the Adapty mobile app both show the fallback, because neither can run your code.
You can publish the flow before the app update ships, and your users on the current version see the fallback until they update. To test a flow that real users don't see yet, add it to a placement that your test build requests and your released app doesn't. Register the device as a test device, so it loads the latest published flow instead of a cached one. If the fallback shows on the test device, the Xcode console names the element that no resolver served.
Test every screen with a custom element before the release, because an error in the native view can crash the app. Once it works, put the new screen in an A/B test arm against your current one. We don't have conversion numbers for custom elements yet, so your own test decides whether the next view is worth a sprint.
What do your users see when the app can't render the custom element?
Your users see the fallback content you put inside the block. That happens when their app version doesn't include the view, when the app runs an SDK that doesn't render custom elements yet, such as Android or Flutter today, when the Type and ID don't match the app code, or when the app returns no view on purpose. A map that needs location returns nothing if the user denied access before the screen opened. If the user hasn't answered yet, the view asks for access itself.
Design the fallback as a finished screen, since every user on an older version sees it: a still image of the ring or a picture of the chart. A block without fallback content stays empty. Keep purchase buttons, navigation and anything else the screen depends on outside the custom element, because a user sees either the native view or the fallback, never both.
Support for Android and cross-platform SDKs is upcoming. Until then, those apps show your fallback, and the flow itself already runs there.
What can't custom elements do in v1?
A custom element can't talk back to the flow yet. The native view shows inside the flow, but it can't trigger flow actions, and the value a user picks in it doesn't reach flow variables. If a user picks a height or spins the wheel, the next screen can't change its copy or its offer based on that answer. Your app knows the result, but the flow can't use it yet.
A few layout rules apply. Keep touch-heavy views out of carousels and product cards, and keep the default Fixed height, since a map with Hug height can collapse to almost zero. Footers, Sliding sheets and Bottom Sheets can't go inside a custom element. Your designer meets these rules in the builder, and the custom elements docs list them all.
The bottom line
A screen that lives in code costs you a release every time you want to test it. With custom elements, that screen costs one release, for the view, and every test after it ships with a publish.
If one screen kept your onboarding or paywall out of the builder, start there. Rebuild the flow in the Flow & Paywall Builder with the custom piece as a custom element, and send your developers the brief above.



