Every item is $19. Or get all items for $259, paid once.

Get all items
mebius.design
mebius.design

shadcn form examples by use case: login, sign-up, checkout and more

shadcn/ui gives you the parts of a form: the Field component for labels, controls and errors, guides that wire it to React Hook Form or TanStack Form, and blocks for login and sign-up. For anything else, compose those parts or start from a finished form. Below are examples for login, sign-up, multi-step, checkout, settings, booking and surveys from mebius.design’s 128 free React forms, which install with the shadcn CLI.

9 min readUpdated Nov 17, 2026React + Tailwind

The shadcn form pattern in brief

Field for the layout, a form library for the state, a schema for the rules.

shadcn/ui’s forms docs pair its Field component with a form library and have guides for React Hook Form, TanStack Form and Formisch (React’s useActionState is marked as coming soon). The React Hook Form guide works like this:

  • A Zod schema holds the rules and the messages (any Standard Schema library works).
  • useForm takes the schema through zodResolver, with defaultValues for every field.
  • Each input sits in a Controller that hands it field (the value and its handlers) and fieldState (whether it’s invalid, and the error).
  • Field and FieldLabel lay out the row; data-invalid on the Field and aria-invalid on the control mark an error, and FieldError shows it.
  • The form submits through form.handleSubmit(onSubmit), so your handler only sees valid data.

That gives you accessible fields in your own theme, shown on examples from a bug report to notification settings. The form around the fields is still yours to design: its layout, the states between submit and success, and details like a password meter or a card number that formats itself. The examples below have those done.


Login forms

Two fields and a lot of small jobs.

A good React login form gets people in on the first try:

  • The fields carry autocomplete="username" and "current-password", so password managers fill them.
  • A show-password button and a Caps Lock warning save a failed attempt.
  • A wrong password keeps the email, selects the password and shows the server’s message.

The Sign In Form does all three, with provider buttons that show a spinner while your call runs and a dithered art panel that becomes a band above the fields on phones. Pass your brand, your providers and your sign-in request; a thrown error becomes the form’s message:

components/sign-in.tsx
"use client"

import { LoginDitherForm, type LoginDitherFormValues } from "@/components/login-dither-form"

async function signIn(values: LoginDitherFormValues) {
  const response = await fetch("/api/auth/sign-in", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(values),
  })
  // A thrown message shows above the button, and the password is selected for retyping.
  if (response.status === 401) throw new Error("Wrong email or password.")
  if (!response.ok) throw new Error("Couldn’t sign you in. Try again in a minute.")
  window.location.assign("/dashboard")
}

// While this promise is pending, the provider's button shows a spinner.
async function continueWith(provider: string) {
  const response = await fetch(`/api/auth/${provider}/start`, { method: "POST" })
  if (!response.ok) throw new Error("Couldn’t start the sign-in. Try again.")
  const { url } = (await response.json()) as { url: string }
  window.location.assign(url)
}

export function SignIn() {
  return (
    <LoginDitherForm
      title="Sign in to Acme"
      description="Use your work email."
      brandName="Acme"
      quote={null}
      providers={[
        { id: "google", label: "Google", icon: <img src="/logos/google.svg" alt="" className="size-3.5" /> },
        { id: "github", label: "GitHub", icon: <img src="/logos/github.svg" alt="" className="size-3.5" /> },
      ]}
      onProviderSignIn={continueWith}
      onSubmit={signIn}
      forgotPasswordHref="/forgot-password"
      signUpHref="/sign-up"
    />
  )
}

Around it: the Reset Password Form (an emailed 6-digit code, then a new password with a strength meter) and the Two-Factor Setup Form (authenticator app, passkey or text message, then recovery codes). For a plain login in shadcn’s own style, start from one of shadcn/ui’s five login blocks.


Sign-up and waitlist forms

Ask for less, and say what happens next.

  • Ask only for what the first session needs; the rest of the profile can wait.
  • Show the password rules and strength while people type, not after a failed submit.
  • End on what happens next: a code to enter, a link in the inbox, a place in line.

The Create Account Form rates the password as you type, tags the email Work or Personal from its domain and shows each country’s dial code. The Create Your Profile Form turns an uploaded photo into an ASCII avatar. For a waitlist, the Request Access Form takes only work emails and counts the seats left, and the Join the Waitlist Form ends on the new place in line. shadcn/ui’s five signup blocks are the plain alternative.


Multi-step forms

One state for every answer, validation per step, a review at the end.

In a good multi-step form, Continue validates only the current step, Back never loses an answer, and the last step shows everything before a single submit. The multi-step form guide builds that in plain React. Ready-made:

  • New Project Form: four steps in split panes (details, repository, environment, review), with Edit links on the review step.
  • Paint a Wall Form: a four-step open call with a wall picker, a calendar and a sketch upload.
  • Job Application Form: three pages filed like tabs in a folder, with a draft that saves itself.
  • Workspace Setup Form: an onboarding step that checks live whether the workspace URL is free.

New Project and Paint a Wall are in the open starter pack: MIT code you install from a URL, no account needed.


Checkout and payment forms

Show the total, catch card typos early, keep the form on a decline.

  • Show the total and what it’s made of, and update it as options change.
  • Group the card number as it’s typed, name the network, and check the Luhn checksum, expiry and CVC before anything is sent.
  • On a declined payment, keep everything and say what went wrong.

The Checkout Form is a one-page shadcn checkout page: contact, shipping address, delivery options and card payment, with a total that follows the delivery you pick. The Quick Checkout Form is a one-item React payment form with a discount code. For SaaS plans, the Pro Upgrade Form switches between monthly and yearly prices and takes promo codes, and the Upgrade Plan Form prices seats with the yearly discount and tax. The Pixel Checkout Form (in the MIT starter pack) does the same flow in 8-bit.

Card details go to your payment provider

These forms check the card’s format, not the payment. In production, send card details to your provider’s hosted fields or tokenizer (Stripe Elements, for example), or swap the card row for the provider’s own fields and keep the rest. Card numbers sent to your own server put it in PCI DSS scope.


Settings forms

Edited, not filled: start from the saved values and send only what changed.

  • Open with the saved values and count what has changed, so people know there’s something to save.
  • Let Cancel put the saved values back.
  • Save only the fields that changed, and keep the form open if the save fails.

The Account Settings Form is a shadcn settings dialog built that way: profile, security and preferences in sections, “2 unsaved changes” in the footer, and an onSubmit that also gets the list of changed fields:

components/settings-dialog.tsx
"use client"

import { AccountSettingsForm, type AccountSettingsField, type AccountSettingsFormValues } from "@/components/account-settings-form"

type SavedSettings = { values: AccountSettingsFormValues; emailVerified: boolean; updatedAt: string }

// The form passes the fields that differ from the saved values, so the PATCH carries only those.
async function save(values: AccountSettingsFormValues, changed: AccountSettingsField[]) {
  const patch = Object.fromEntries(changed.map((field) => [field, values[field]]))
  const response = await fetch("/api/me/settings", {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(patch),
  })
  // A rejected promise keeps the dialog open with “Couldn’t save your changes. Try again.”
  if (!response.ok) throw new Error(`Save failed: ${response.status}`)
}

export function SettingsDialog({ saved, onClose }: { saved: SavedSettings; onClose: () => void }) {
  return (
    <AccountSettingsForm
      defaultValues={saved.values}
      emailVerified={saved.emailVerified}
      lastSavedAt={new Date(saved.updatedAt)}
      maxBioLength={160}
      onSubmit={save}
      onCancel={onClose}
      onClose={onClose}
    />
  )
}

Also for settings: the Team Settings Form (an unsaved-changes count and Reset), the Notifications Form (each alert to email, Slack or SMS, with quiet hours) and the Change Password Form (a strength meter with the time it would take to crack the password).


Booking forms

Read availability from your data and name the slot on the button.

  • Build the days and times from real dates and your availability, and strike out taken slots instead of hiding them.
  • Say which time zone the times are in, and let people switch it.
  • Name the chosen slot on the button (“Book Fri 31, 14:00”) and confirm with the end time.

The Schedule a Session Form is a React booking calendar: a week of days, open times split into morning and afternoon, closed days explained and a time zone switch, with your getSlots function supplying the times. The Book an Appointment Form books a service, a day and a slot and confirms the end time and price; the Book Your Stay Form (a hotel), the Book a Table Form (a restaurant) and the Book a Demo Form (work emails only) cover the other common bookings. Schedule a Session is in the open starter pack, so you can try it without an account:

Terminal
npx shadcn@latest add https://www.mebius.design/r/forms-pro-session-scheduling.json

Survey and feedback forms

Short, usable from the keyboard, and a thank-you that repeats the answer.

  • Ask one thing per screen, or keep the card short.
  • Make a 0–10 scale a real radio group, so arrow keys and screen readers work.
  • End by repeating the answer, so people see it arrived.

The Quick Question Form is an NPS survey whose onSubmit gets the score with its category (detractor, passive or promoter). The Team Survey Form asks one question per card, Typeform style, with answers you can pick by their letter. The Product Feedback Form adds a screenshot upload, and the Write a Review Form takes a star rating and photos.


Form UI design rules they share

The same behaviour in all 128 forms, whatever their style.

The mebius forms come in many looks (clean, dither, pixel, ASCII, Swiss, glass), but they follow the same form design rules:

  • Each error sits next to its field, which gets aria-invalid and points to the message with aria-describedby.
  • Submit validates, moves focus to the first field to fix and shakes the form once.
  • The button shows progress while your onSubmit runs; a rejected promise keeps everything typed and shows an error.
  • Success shows a confirmation in place of the fields, usually with a way back.
  • With reduced motion turned on nothing animates, and light and dark follow your app’s dark class.

Install and adapt them

React 19, Tailwind CSS v4 and the shadcn CLI.

All 128 are on the free shadcn forms page, each with a live demo. Add the @mebius registry once (setup guide), install the kit’s theme on its own, then the form with --overwrite:

Terminal
npx shadcn@latest add @mebius/forms-pro-theme
npx shadcn@latest add @mebius/forms-pro-login-dither --overwrite

Names start with their kit (forms- for the 20 Forms, forms-pro- for the 108 Forms Pro). A free account and a token from Settings › Tokens unlock them all; the ten starter forms install from their URL without one.

  • They are styled, not neutral: re-skin one through its colour variables or Tailwind classes, because it won’t pick up your shadcn theme.
  • They aren’t built from shadcn/ui’s Field and Input. Each form is one file with its own markup, validation and anime.js motion, and the theme’s tokens all start with form-, so your app’s colours stay as they are.
  • There’s no form library inside: the values come out through onSubmit. In an app built on React Hook Form, use one as a whole form rather than wiring its fields into useForm.
  • The code of ten forms is MIT; the rest are free to use in your projects under the mebius.design licence. Every form comes with its Figma file.

More shadcn form examples

Other good sources, checked in November 2026.

  • shadcn/ui (MIT). The reference: Field and the form guides above, plus five login and five signup blocks, neutral and in your theme. It ships code only; its docs list community Figma kits, four free and nine paid.
  • shadcn.io, an independent site built on shadcn/ui: 42 form examples (login, sign-up, profile, settings, checkout, contact, and validation patterns such as password strength and conditional fields) on its own Field components with React Hook Form and Zod. Free with an account; a paid Pro plan adds agent installs and MCP access. The page offers no Figma files, and none of the 42 is a multi-step form.
  • WrapPixel’s list of 15 shadcn forms (updated July 2026): previews of single forms, such as an onboarding form with a progress bar, a multi-section settings form and a step-by-step checkout, from several template sites, most of them Shadcn Space. It names no licences or prices, so check each source.
  • formcn: a visual form builder. Start from a template (login, sign-up, waitlist, contact, survey, job application and more) or your own fields, choose one step or several, and it writes shadcn/ui code with React Hook Form and Zod that the shadcn CLI adds. Free to use; its README calls it open source, but the repository had no licence file when we checked.

Use shadcn/ui’s own pattern when the form should match the rest of your app exactly, or when nobody has built the form you need; formcn saves typing on a plain form with many fields, and shadcn.io is handy for small validation patterns. Start from a mebius form when you want a finished, designed form with its states and motion done and a Figma file to match.


Item pages, kits and guides this guide uses.