Photo Social App with FlutterFlow and Supabase · Course book
Chapter 12: Designing Onboarding
A brand-new account has an email address and nothing else. Before the new user starts posting, the app should help them set up a profile: choose a username, add a photo, write a short bio. A short, friendly onboarding sequence does this, one step per screen, with a clear sense of progress and an easy way back. This chapter designs that sequence in FlutterFlow with the PageView widget, which shows several swipeable pages inside a single page so that they can share state. It covers why a PageView suits onboarding, how to design each step, how to show progress, worked out by hand, and how the cancel and back buttons should behave.
Why a PageView
Onboarding could be built as several separate FlutterFlow pages, navigating from one to the next. The difficulty is that each page has its own page state, so the username typed on step one would have to be passed as a parameter to step two, then both to step three, and so on, with the risk of losing values along the way. A PageView avoids this. It is a single widget, on a single page, that contains several child pages arranged side by side; only one is visible at a time, and the user moves between them by swiping or by buttons that call an action to go to the next or previous child. Because all the children live on the same FlutterFlow page, they share that page's state: whatever is typed on step one is still available on step three.
| Approach | Sharing values between steps | Going back | Best for |
|---|---|---|---|
| Separate pages | Pass parameters forward at every step, or use app state | Navigation history | Long, branching flows |
| One page with a PageView | Automatic, through the page's state | Animate to the previous child | Short, linear flows such as onboarding |
A PageView has a controller that knows which child is showing, and FlutterFlow provides actions to animate to the next or previous child or to a specific index. Swiping can be enabled, which feels natural, or disabled, so that users must use the buttons, which is useful when a step must be completed before moving on. For onboarding, disabling swipes is usually the better choice: a swipe can skip a required step by accident, while buttons make each move deliberate and let the app check the step's input first, for example that the username is long enough and not already taken, before animating to the next child.
Designing the steps
Each step asks for one thing and explains why. Short steps feel quick and make it obvious what to do; a single long form feels like work. A typical onboarding for a photo app has three steps.
- Choose a username: a single text field with a hint about allowed characters, and a message that it can be changed later.
- Add a profile photo: a large circular placeholder with a button to choose from the gallery or take a photo, and a "skip for now" link.
- Write a bio: a multi-line field with a character counter, also skippable, and a final "Finish" button.
Every step shares a common layout: a top row with a back or close control and a progress indicator, a title in large type, a sentence of explanation, the input itself in the middle, and a primary button at the bottom, labelled "Next" on all but the last step. Keeping the layout identical makes the sequence feel like one coherent flow rather than three unrelated screens, each built differently.
Showing progress
People are more willing to complete a short task when they can see how much is left. A thin progress bar at the top, or a row of dots, shows the current step out of the total. The progress value is the current step divided by the number of steps.
The progress indicator should update as the PageView changes, which FlutterFlow supports by reading the PageView's current index. A label such as "Step 2 of 3" helps users who cannot see the bar clearly and gives screen readers something meaningful to announce.
Cancel and back buttons
Navigation inside onboarding needs two distinct controls. A back button on steps two and three moves to the previous child of the PageView, keeping everything entered so far. On the first step there is nothing to go back to, so the button is either hidden or replaced with a cancel control. What cancel does is a design decision: it might skip onboarding entirely and go to the home feed, with a default username and no photo, or ask for confirmation before discarding the setup. Since onboarding follows sign-up, cancelling should never leave the user in an awkward state, for example signed in but with no profile row.
The phone's own back gesture should behave consistently with these buttons. On Android, the system back button on step three should go to step two, not leave the onboarding page entirely, which FlutterFlow can handle by intercepting back navigation on the page. Skippable steps should say so clearly, with a "Skip for now" link below the main button, and the profile page later should make it easy to add whatever was skipped.
This part designs the sequence and its navigation. The next part makes it functional: navigating to onboarding after sign-up, wiring up each step's input, creating the users table row with the collected data, and allowing users to log out.
The app must also decide when to show onboarding at all. It belongs only to users who have not completed it, so the app needs a way to tell. A simple rule checks whether the user's profile row exists, or whether its username is still empty: if so, onboarding is shown after sign-in; if not, the user goes straight to the feed. Storing an explicit "onboarded" flag on the profile row is clearer still, and it survives reinstalling the app or signing in on a new phone, which a flag kept only on the device would not.
Transitions between steps should be quick and consistent, a short horizontal slide of around 300 milliseconds being typical, so that the movement shows direction without slowing the user down. Users who have asked their phone to reduce motion may prefer an instant change, and respecting that setting is a small accessibility courtesy. Each step's main button should also be reachable with the keyboard open: when the username field is focused, the keyboard covers the lower part of the screen, so placing the field near the top and letting the step scroll ensures the Next button can still be tapped. Testing the sequence with a brand-new account, then with an existing one, confirms that onboarding appears exactly when it should.
Designing for completion
Every extra step loses some users, so onboarding should ask only for what the app genuinely needs at the start. A username is essential, because it appears on every post and comment. A photo and a bio make profiles friendlier but can be added later, so they are skippable. Pre-filling sensible defaults, such as suggesting a username based on the email address, reduces effort further. Explaining the benefit of each step, "A photo helps friends recognise you", turns a chore into a reason. And making the final step feel like an arrival, with a friendly message as the home feed appears, ends the sequence on a positive note. A handful of suggested accounts to follow, shown at the end, can also fill an otherwise empty first feed.
Practice tasks
- An onboarding has five steps. What does the progress bar show on each step, as a percentage?
- On a 414-point screen, what are the offsets of a four-step PageView's children, and which index is visible at offset 828?
- From step two of three on a 390-point screen, the user drags 150 points and lets go. Which step shows, and why?
- Explain why a PageView makes it easier to share values between onboarding steps than separate pages.
- What should the cancel button on the first step do, and what must it never leave behind?
- Decide which onboarding steps should be skippable for a photo app, and justify each choice.
This course book is available to read online only at tech-academy.chrysolites.org.