Looking to make your quizzes, calculators, or surveys smarter? You’re in the right spot. If you’re tired of boring, one-size-fits-all forms, and you want to use Outgrow to build something that actually reacts to users’ answers, you’ll need to wrap your head around logic jumps.
Logic jumps let you control what people see next, based on what they just told you. Think “choose your own adventure,” but for lead gen. This guide walks you through why logic jumps matter, how to set them up, and how to avoid the common mistakes that make things clunky and confusing.
This isn’t just for data nerds or marketers, either—if you want your forms to actually convert, you need to make them feel personal. Let’s dig in.
What Are Logic Jumps, Really?
At their core, logic jumps are rules you set up that change the path someone follows through your Outgrow experience. For example:
- If someone says their budget is $500, show them affordable options.
- If a user picks “dog” as their pet, skip the cat food questions.
- If someone answers “yes” to a question, ask for more details. If “no,” move on.
Without logic jumps, every user gets the same questions in the same order—boring, and often a waste of their time. With logic jumps, you can show only what’s relevant, which makes people more likely to finish and give you good data.
Pro tip: Logic jumps are the difference between a quiz people finish and one they abandon halfway. Don’t overcomplicate, but don’t skip them, either.
Step 1: Map Out Your User Paths Before You Start
Before you even log in to Outgrow, get clear on what you want to happen when users give different answers. This is the step people skip, but it saves headaches later.
- Grab a pen or open a flowchart tool.
- Write out your questions in order.
- For each, jot down what should happen if someone picks each answer.
- Where do you want to skip, branch, or show custom follow-ups?
You don’t need a fancy diagram—boxes and arrows are fine. The point is, don’t try to wing it inside the Outgrow editor. You’ll get lost fast, especially if your experience has more than a handful of questions.
What to ignore: Don’t try to logic-jump every single question. Only branch where it actually changes the experience for the user.
Step 2: Build Your Base Questions in Outgrow
Now, head into Outgrow and start building out all your questions, even the ones you might skip or branch around. This gives you the “building blocks” for logic jumps later.
- Create all the questions you’ll need, in the order that makes some sense.
- Use clear, direct language for each question and answer.
- Add answer options for multiple choice, dropdowns, etc.
Don’t worry about logic yet—just get everything down. You’ll connect the dots in a minute.
What works: Simple, short questions. The more complicated your questions, the harder it’ll be to set up logic that makes sense.
Step 3: Add Logic Jumps (The Actual Setup)
Here’s where the magic happens. Outgrow lets you add logic jumps in the question editor. Here’s how:
- Open the Logic Editor:
- Click on the question you want to branch from.
-
Find the “Logic Jump” or “Conditional Logic” option (usually a button or tab).
-
Set Your Conditions:
- For each possible answer, pick what should happen next.
- You can send users to a specific question, skip some, or even jump to the results.
For example:
- If answer is “Yes” → Go to Question 4
- If answer is “No” → Go to Question 6
- Repeat as Needed:
- Go through your questions one by one.
-
Add logic only where you need it (as mapped out earlier).
-
Test Each Path:
- Use the preview mode.
- Select different answers and make sure users end up where you want.
Pro tip: Start small. Test one logic jump at a time before layering on more. Outgrow’s editor is decent, but it’s easy to lose track if you build a spiderweb of jumps all at once.
Step 4: Handle Results and Outcomes
Logic jumps aren’t just for skipping questions—they can customize the final result or outcome, too. For example, you might want to:
- Show different recommendations based on answers.
- Display a custom message or CTA.
- Route leads to the right follow-up email sequence.
How to do it in Outgrow:
- Go to the Results or Outcomes section.
- Set up conditions, just like with questions.
- For each outcome, define which answers or score ranges trigger it.
What doesn’t work: Don’t try to get too granular here. If you have 20 possible outcomes, your users (and you) will get lost. Stick to a handful of clear, useful results.
Step 5: Avoid Common Logic Jump Pitfalls
Logic jumps are powerful, but easy to mess up. Here’s what to watch out for:
-
Overcomplicating the flow:
If every question branches in three directions, you’ll create a mess. Users hate getting lost or seeing inconsistent logic. -
Forgetting “all else” cases:
Always set a default path for answers you didn’t anticipate. Outgrow lets you add “else” conditions—use them. -
Not testing edge cases:
Try weird answer combos. Make sure nobody gets stuck in a loop or dead-ends halfway. -
Ignoring mobile:
If your logic jump setup makes the quiz super long on mobile, users will bail. Keep it tight.
What actually works:
- Stick to logic jumps that matter—where the answer genuinely changes what you should ask next or what you’ll recommend.
- Use the Outgrow preview mode constantly.
- Keep a cheat sheet of your question flow handy.
Step 6: Review, Test, and Iterate
After you’ve set up your logic jumps, don’t assume it all works. Even simple setups can break if you miss a link.
- Go through every possible path as a user would.
- Invite a colleague or friend to try your quiz and see where they get stuck.
- Watch for:
- Unexpected skips
- Loops
- Wrong outcomes
Pro tip: Outgrow doesn’t always make it obvious if you’ve got a “dead end.” If a user reaches a spot with no next question or result, you’ll lose them.
When Logic Jumps Aren’t Worth It
Sometimes, it’s tempting to use logic jumps everywhere. Don’t. Here are cases where you don’t need them:
- If the experience is only 3–4 questions long.
- If the added branches don’t change the end recommendation or output.
- If your audience just wants quick answers (e.g., price calculators).
Use logic where it adds value. Otherwise, just keep it linear and simple.
Shortcuts, Limitations, and Honest Truths
-
Outgrow’s logic jump editor is visual, but can get messy fast.
If your project is complex, keep a backup flowchart. -
There’s no “undo” for logic jumps.
If you break something, you might have to rebuild that section. -
Performance can take a hit with tons of logic.
More logic means more browser work, especially on mobile. -
You can’t do everything.
Outgrow’s logic jumps are powerful, but not as flexible as scripting or code-heavy form builders. If you need crazy complex flows, you might hit a wall.
Keep It Simple, Iterate Often
Logic jumps in Outgrow can turn a generic quiz into something surprisingly smart. But don’t get too clever—simple, clear paths work best. Build your core flow, test it, and tweak. If you get lost, step back and ask if the extra logic is really helping.
Remember: you can always add more branches later. Start with the basics, make sure it works, and let user feedback guide what you change next. That’s the real secret to smart, effective forms—no BS required.