How to Set Up Conditional Logic in Formsort to Personalize User Journeys

If you're building forms that matter—think onboarding, qualification, or anything more complex than a basic contact form—you know a "one size fits all" approach just doesn't cut it. You want to show users only what's relevant, skip what doesn't apply, and keep the flow tight. That's where conditional logic comes in. This guide is for anyone who wants to use Formsort to personalize user journeys, whether you're a product manager, a developer, or just the person who got handed the forms project (again).

Let's get into how to set up conditional logic in Formsort, what actually works, and what you can skip.

Why Conditional Logic Matters (and When to Use It)

Conditional logic lets you change what users see—or don't see—based on their answers. This can mean:

  • Skipping irrelevant questions
  • Showing extra fields if someone says "yes" to a certain question
  • Routing users down totally different paths based on their responses

Done right, it keeps forms short and relevant. Done badly, it can confuse users or make maintenance a nightmare. So use it to simplify, not complicate.

When is conditional logic worth it?

  • When your form has different paths for different audiences (e.g., patients vs. providers).
  • When you need to collect extra info only from some users.
  • When you want to avoid bombarding users with questions that don’t apply.

If your form is five questions long, skip the logic. If you’re already mapping out routes on a whiteboard, you probably need it.

Step 1: Get Your Form Structure Right First

Before diving into logic, map out your form’s structure. In Formsort, you work with "steps" (think: pages or screens) and "fields" (individual questions or inputs). Here’s what you should do:

  • List out every field and step. Use a spreadsheet or diagram.
  • Decide which questions are always shown, and which are conditional.
  • Group related questions together. It makes applying conditions easier.

Pro tip: If you try to add conditions before you know what goes where, you’ll end up redoing things. Get the skeleton built, then layer on logic.

Step 2: Understand Formsort’s Conditional Logic Basics

Formsort uses something called "visibility conditions" to power logic. You can apply these to steps, fields, and even options within fields (like dropdown choices).

  • Visibility Condition: A rule that decides whether something shows up, based on previous answers.
  • Expressions: The formulas or conditions themselves, like age >= 18 or employment_status == "self-employed".

You’ll mostly be:

  • Showing or hiding steps based on earlier answers
  • Skipping sections entirely
  • Displaying extra info or warnings only when relevant

Formsort’s logic builder is visual, but you can also write conditions manually if you’re comfortable.

Step 3: Add Your First Conditional Field

Let’s walk through a simple example: Show a “What’s your business name?” field only if someone says they're self-employed.

  1. Create the "Are you self-employed?" question.

    • Make this a yes/no or single-select field.

  2. Add the "What’s your business name?" field.

    • Place it right after the self-employment question.

  3. Set a visibility condition:

    • In the "What’s your business name?" field settings, find the "Visibility" or "Show if" option.
    • Use the logic: employment_status == "self-employed" (adjust the field name as needed).

  4. Test it.

    • Preview the form. When you select "self-employed," the business name field should appear.

What’s good: This keeps the form uncluttered for users who aren’t self-employed.

What to watch for: Double-check your field keys/names. Typos in logic are a common source of silent errors.

Step 4: Branch Entire Steps or Paths

Conditional logic gets more powerful (and riskier) when you start skipping whole steps.

Example: You want to show a "Household Information" step only if someone says they’re applying with family.

  1. Create the branch question: “Are you applying with family?”
  2. Add the "Household Information" step.

  3. Set a visibility condition on that step:

    • applying_with_family == true

  4. (Optional) Set up skip logic:

    • Some flows might use "goto" logic to jump ahead or split into different paths. Use this sparingly—it can get confusing fast.

Pro tip: Too many branches make forms hard to update later. Stick to clear, high-value branches. Draw out your logic on paper if you’re unsure.

Step 5: Using Advanced Expressions and AND/OR Logic

Sometimes you need more than a simple if/then. Formsort lets you use AND, OR, and even nested conditions.

Example: Only show the "Upload paystub" field if the user is employed and earns more than $50,000.

  • Set the visibility to:
    employment_status == "employed" && annual_income > 50000

Tips:

  • Use parentheses to clarify logic when combining multiple conditions:
    (employment_status == "employed" && annual_income > 50000) || (self_employed == true && business_duration > 2)
  • Don’t overdo it. The more complex your logic, the more likely you or a coworker will break it later.

What to ignore: Don’t try to replicate every possible path. Focus on the biggest differences, not every edge case.

Step 6: Show or Hide Field Options Conditionally

Formsort also lets you hide or show individual options within a dropdown or multiple-choice field.

Real-world use: If you have a “State” dropdown and want to hide "Alaska" and "Hawaii" if shipping isn’t available there.

  • In the field’s settings, set a visibility condition on each option as needed.

Why bother?
It’s cleaner than showing options that lead nowhere or require extra error handling later.

Step 7: Test (and Break) Your Logic

This is where a lot of forms go wrong. Don’t trust that your logic works—try to break it.

  • Run through every path as a user would
  • Try combinations you didn’t plan for
  • Check what happens if someone goes back and changes an earlier answer

Pro tip: Use Formsort’s preview and debug tools. If you have teammates, get fresh eyes to test the flow.

What to ignore: Avoid over-relying on automated checks. Manual walkthroughs catch weird issues.

Step 8: Keep It Maintainable

Conditional logic can spiral out of control. Here’s how to avoid a mess:

  • Name your fields and steps clearly. Future you (or someone else) will thank you.
  • Document tricky logic. Use comments or a shared doc for anything non-obvious.
  • Review logic when you make changes. Even small edits can break flows elsewhere.

When to refactor:
If you find yourself adding more than two or three layers of nested logic, step back. It might be time to rethink your form structure, or split into multiple forms.

Honest Pros, Cons, and Gotchas

What works:

  • Keeping forms shorter and more relevant
  • Handling different user types in one flow

What doesn’t:

  • Overcomplicating logic for small gains
  • Trying to handle every possible scenario in one mega-form

Common pitfalls:

  • Logic that conflicts or creates dead ends
  • Fields that are required but hidden, making the form impossible to submit
  • Forgetting to test paths where users change their answers mid-way

Wrapping Up: Start Simple, Iterate Often

Conditional logic in Formsort is powerful, but it’s easy to overdo it. Start with the biggest wins—hide what’s irrelevant, branch when it really matters, and keep your flows maintainable. The best forms get out of the user’s way, so build, test, and don’t be afraid to trim logic that’s more trouble than it’s worth. If it feels confusing to set up, it’s probably confusing for your users, too. Keep it simple, and you’ll build forms people actually finish.