Multi-Step Forms with Form State
Split a long registration form into multiple steps using a step counter in state, validate only the current step's fields before advancing to the next.
Multi-Step Forms with Form State is a free React Native Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the React Native Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
What Is a Multi-Step Form?
A multi-step form breaks a long registration or checkout flow into discrete, manageable steps — typically 2 to 5 screens. Each step focuses on a related group of fields, reducing cognitive load and improving completion rates compared to a single long scroll. Common examples include onboarding wizards, address-plus-payment checkout flows, and multi-stage profile setup.
Sharing One Form Instance Across Steps
The key to a multi-step form with react-hook-form is to create one useForm instance for the entire form and pass control and errors down as props to each step component. This keeps all field values and validation state in one place. Values entered on step 1 remain available when the user reaches step 3, and submitting the final step accesses the complete form data.
interface RegisterForm {
name: string;
email: string;
password: string;
phone: string;
city: string;
}
export default function RegisterScreen() {
const [step, setStep] = React.useState(1);
const form = useForm<RegisterForm>({ defaultValues: { name: '', email: '', password: '', phone: '', city: '' } });
return (
<View style={styles.container}>
{step === 1 && <Step1AccountInfo form={form} />}
{step === 2 && <Step2ContactDetails form={form} />}
{step === 3 && <Step3Review form={form} onSubmit={handleFinalSubmit} />}
</View>
);
}Defining Step Component Props
Each step component receives the form instance as a prop. Define a TypeScript type for the prop using UseFormReturn from react-hook-form. This gives the step component access to control, formState.errors, trigger, and watch — all the tools needed to render and validate its own subset of fields.
import type { UseFormReturn } from 'react-hook-form';
interface StepProps {
form: UseFormReturn<RegisterForm>;
onNext?: () => void;
}
export function Step1AccountInfo({ form, onNext }: StepProps) {
const { control, formState: { errors } } = form;
// Render only name, email, and password fields
}Validating Only the Current Step
Before advancing to the next step, validate only the fields on the current step using form.trigger(['fieldA', 'fieldB']). This runs validation on the specified fields and returns a Promise that resolves to true if all are valid. If any fail, the errors appear and the user cannot advance until they are fixed. Fields on later steps are not validated yet.
async function handleNext() {
const step1Fields: (keyof RegisterForm)[] = ['name', 'email', 'password'];
const isValid = await form.trigger(step1Fields);
if (isValid) {
setStep(2);
}
// If invalid, formState.errors is populated for the listed fields
}Progress Indicator UI
Add a visual progress bar or step indicator at the top of the screen so users know how far along they are. Calculate progress as (currentStep / totalSteps) * 100. A simple progress bar using an animated View width gives clear feedback and sets expectations about how much more is required before they can complete the form.
const TOTAL_STEPS = 3;
function ProgressBar({ current }: { current: number }) {
const progress = (current / TOTAL_STEPS) * 100;
return (
<View style={styles.progressContainer}>
<View style={[styles.progressFill, { width: progress + '%' }]} />
</View>
);
}
// Usage:
<ProgressBar current={step} />Navigating Between Steps
Use a step counter in useState to track the current step. 'Next' buttons validate the current step's fields with trigger before incrementing the step. 'Back' buttons decrement the step without re-validating. Always disable the 'Next' button or show a loading spinner while async validation (like username availability checks) is in progress.
const { formState: { isValidating } } = form;
function NavigationButtons() {
return (
<View style={styles.navRow}>
{step > 1 && (
<Button title='Back' onPress={() => setStep((s) => s - 1)} />
)}
{step < TOTAL_STEPS ? (
<Button
title={isValidating ? 'Checking...' : 'Next'}
onPress={handleNext}
disabled={isValidating}
/>
) : (
<Button title='Submit' onPress={form.handleSubmit(onFinalSubmit)} />
)}
</View>
);
}Reviewing Entered Data on the Final Step
The final step is often a review screen where users confirm their entries before submitting. Use form.getValues() to read all field values and display them in a summary list. This gives users one last chance to catch typos before the data is sent to the server, reducing support requests and user errors.
function Step3Review({ form, onSubmit }: StepProps) {
const values = form.getValues();
return (
<ScrollView>
<Text>Review your information:</Text>
<Text>Name: {values.name}</Text>
<Text>Email: {values.email}</Text>
<Text>Phone: {values.phone}</Text>
<Text>City: {values.city}</Text>
<Button title='Confirm and Register' onPress={onSubmit} />
</ScrollView>
);
}Using formState.isSubmitting
formState.isSubmitting is true while handleSubmit's async callback is running. Use it to disable the submit button and show a loading spinner during the API call. This prevents double-submissions when the user taps quickly and gives clear feedback that the form is being processed.
const { formState: { isSubmitting } } = form;
<Button
title={isSubmitting ? 'Submitting...' : 'Confirm and Register'}
onPress={form.handleSubmit(onFinalSubmit)}
disabled={isSubmitting}
/>Persisting Step Data Across Navigation
If users navigate away from the multi-step form and return later, use Zustand or React Navigation's route params to preserve the current step and partially filled form data. Combine this with react-hook-form's reset(savedValues) to restore the form to where the user left off. This dramatically reduces form abandonment on mobile.
// On unmount or navigation away:
useEffect(() => {
return () => {
const currentValues = form.getValues();
useFormDraftStore.getState().saveDraft(currentValues, step);
};
}, []);
// On mount, restore if draft exists:
useEffect(() => {
const draft = useFormDraftStore.getState().draft;
if (draft) {
form.reset(draft.values);
setStep(draft.step);
}
}, []);Keyboard Navigation Between Fields
On mobile, tapping 'Next' on the keyboard should move focus to the next input within a step. Use useRef to hold refs for each TextInput and call ref.current.focus() in the onSubmitEditing callback of each input. Set returnKeyType='next' on intermediate fields and 'done' on the last field of each step.
const emailRef = React.useRef<TextInput>(null);
const passwordRef = React.useRef<TextInput>(null);
<TextInput
placeholder='Full Name'
returnKeyType='next'
onSubmitEditing={() => emailRef.current?.focus()}
/>
<TextInput
ref={emailRef}
placeholder='Email'
returnKeyType='next'
onSubmitEditing={() => passwordRef.current?.focus()}
/>
<TextInput
ref={passwordRef}
placeholder='Password'
returnKeyType='done'
onSubmitEditing={handleNext}
secureTextEntry
/>Handling Back Navigation Safely
When the user presses the hardware back button on Android or swipes back on iOS, handle it to decrement the step counter instead of leaving the screen entirely. Use useFocusEffect with a BackHandler to intercept the hardware back event. If the user is on step 1, allow normal navigation back to the previous screen.
import { BackHandler } from 'react-native';
import { useFocusEffect } from '@react-navigation/native';
useFocusEffect(
React.useCallback(() => {
const handler = BackHandler.addEventListener('hardwareBackPress', () => {
if (step > 1) {
setStep((s) => s - 1);
return true; // prevent default back navigation
}
return false; // allow default (exit screen)
});
return () => handler.remove();
}, [step])
);Quick Check
Test your understanding of React Native Mobile Development concepts from this lesson.
Lesson Recap
In this lesson you learned: one useForm instance shared across all steps keeps form data and validation state unified, trigger with specific field names validates only the current step before advancing, and formState.isSubmitting disables the submit button during the final API call to prevent duplicate submissions. Next up we explore submitting and resetting forms.
Frequently asked questions
Is the “Multi-Step Forms with Form State” lesson free?
Yes — the full text of “Multi-Step Forms with Form State” is free to read here on the web, and the React Native Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the React Native Academy course, upgrade to CoddyKit PRO.
What will I learn in “Multi-Step Forms with Form State”?
Split a long registration form into multiple steps using a step counter in state, validate only the current step's fields before advancing to the next. You practise React Native Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start React Native Academy?
No prior experience is required. React Native Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Multi-Step Forms with Form State” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this React Native Academy lesson?
Yes. Every React Native Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Setting Up react-hook-form with Controller
- Validation Rules and Error Messages
- Multi-Step Forms with Form State
- Submitting and Resetting Forms