Loading tutorials…
Loading tutorials…
Logic jumps are what turn a static form into a smart one. They are also where most Tally forms quietly break. This walks through the branching patterns that actually hold up at scale.
Who this is forMarketers building forms with branching logic — qualification forms, multi-product onboarding, conditional demo flows. If you have 8+ questions and not all apply to every user, you need logic jumps.
What you'll need
Step 1
Draw a decision tree: every question, every possible answer, every resulting jump. Logic in Tally is hard to refactor — get the map right first.
Open a whiteboard, Miro, or even a napkin. Draw the first question and every possible answer.
For each answer, draw an arrow to the next question (or to the end). Repeat for every question.
Look for orphan paths: any answer that does not have a clear next step. Fix on paper before building.
Look for dead ends: branches that hit the thank-you page without collecting required data. Fix on paper.
Save the map. You will need it when testing.
Step 2
Click a question → Logic → Add condition. Set: "If answer is X, jump to question Y." Save.
Open the form in Tally editor. Click any question to open its settings panel.
Click "Logic" tab → "Add logic jump."
Set condition: "If [this question] is/contains/equals [value]." Set action: "Jump to [question name]" or "Skip to end."
Save. Repeat for every branch from your map.
For multi-condition logic ("If role = Marketing AND company size > 100"), use the "Add condition" button to chain ANDs and ORs.
Step 3
Tally's Calculated Fields block lets you assign scores or compute totals based on answers. Useful for qualifiers, quizzes, and pricing.
In the editor, add a Calculated Field block. Type: 'Number.'
Set the formula: e.g., `IF({company_size} > 100, 10, 0) + IF({budget} > 5000, 20, 0)`.
Use the calculated value in logic jumps: "If lead_score >= 25, jump to demo-booking. Otherwise, jump to thank-you-newsletter."
Pass the score to your CRM or Notion via the calculated field as a hidden submission value.
Test every score path manually — math errors here are silent killers.
Step 4
Pre-fill or hide fields using URL parameters. Use those values in logic jumps to personalize the form based on traffic source.
In Tally editor, add a hidden field block. Name it (e.g., "source").
In the field settings, enable "Pre-fill from URL parameter." Use parameter name matching the field (e.g., `?source=linkedin`).
Use the hidden value in logic: "If source = linkedin, skip the 'How did you hear about us?' question."
This is how you build one form that adapts to multiple traffic sources without forking the form file.
Step 5
Open the form in incognito. Submit once per branch path. Verify each path reaches a valid end state with correct data.
Open the live form URL in an incognito window.
For each branch in your map, submit a response that takes that path. Note: a form with 4 binary branches has 16 possible paths.
For each submission, verify: (a) the right questions appeared, (b) the right end-state fired (thank-you message or redirect), (c) the right data landed in Notion/CRM.
Document any broken paths. Fix in the editor. Re-test only the broken paths plus one full happy-path.
Common mistakes
Building logic without a paper map
What goes wrong: You build branches one at a time, lose track of which questions go where, and ship a form with at least one orphan path. Users hit a dead end, abandon, and you do not notice for weeks. ~10-20% silent abandonment rate.
How to avoid: Always map on paper or whiteboard first. Treat the map as the source of truth. The Tally editor is just the implementation.
Skipping branch testing
What goes wrong: You test the happy path once, ship the form, and a non-obvious branch is broken for 3 months. The leads taking that path silently fail. At 200 submissions/month, you may have lost 60+ leads ($1,200-3,000 in LTV).
How to avoid: Test every branch in incognito before launch. A form with 4 binary branches needs 8-16 tests. Budget the time.
Using calculator fields without testing math
What goes wrong: A wrong formula sends qualified leads to the newsletter path and unqualified leads to the demo path. You waste sales time and miss real opportunities.
How to avoid: Test the calculator field on at least 5 sample scenarios manually. Use a sheet to verify the math matches what Tally outputs.
Mixing logic jumps with required fields incorrectly
What goes wrong: A required field is skipped by a logic jump, but the form still demands it. Users hit a validation error they cannot understand. ~30-40% abandonment on that branch.
How to avoid: For any field that may be skipped by logic, mark it optional (not required). Validate the data downstream if needed.
No fallback for "Other" answers
What goes wrong: User picks "Other" — your logic does not have a case for it — they hit a dead end or the wrong path. Specifically common with role/industry questions where "Other" is high-frequency.
How to avoid: Always add an explicit "If answer is Other" branch. Either ask a follow-up question or route to a generic path.
Recap
Done — what's next
How to build a Tally form that actually converts
Read the next tutorial
Hand it off
Logic-jumps are simple to build and easy to misconfigure. A vetted conversion-funnel specialist will map, build, and test every branch. From $14-16/hr — most engagements land at $300-700/mo for ongoing form work.
See specialist rates
Yes — basic logic jumps are on Tally Free. Advanced calculator fields and complex multi-condition logic are Pro features. For most use cases, Free is enough.
Technically unlimited. Practically, forms above 8 branches become hard to maintain and test. Split into multiple forms or use a different tool above that complexity.
Yes. Add a Calculated Field, then add logic on the calculated field itself: 'If score >= 25, jump to demo question. Otherwise, jump to newsletter.'
"Skip to [question]" continues the form at that question. "End form" jumps straight to the thank-you page. Use "End form" only for explicit disqualification paths.
Yes. Conditional pricing is a common pattern: ask product/plan questions, calculate a total, then route to the Stripe payment block with the calculated amount.
Tally
Tally's block-based editor is forgiving — which is why most teams build forms that look fine and convert at 18%. This walks through the build path that lands forms at 35-45% conversion.
Tally
Tally + Stripe is the cheapest way to collect online payments without building a custom checkout. Done wrong, you lose 10-15% of would-be customers to confusion. Here's the right setup.
Tally
Quizzes convert 2-3x better than static forms when built right. They also leak 40-60% of completions when built wrong. This walks through the scoring + result pattern that lands quizzes at 50%+ completion.
Tally
DIY forms are great — until your conversion rate caps at 18% and you cannot tell why. Here is the honest framework: when the cost of self-managing exceeds the cost of hiring, and how to tell which side you are on.