Survey logic is the difference between a questionnaire and an instrument. A linear survey asks everyone everything and makes the respondent do the filtering ("skip if not applicable"); a logic-driven survey does the filtering itself, so every respondent sees only the questions that apply to them.

The payoff is double: shorter perceived length (better completion) and cleaner data (no "N/A" guesses polluting your averages). The cost is complexity that can quietly corrupt a dataset if mishandled. This post covers the patterns worth using — branching, skip logic, screening and quotas, piping — and the mistakes that bite.

What's the difference between branching and skip logic?

Definitions first, because tools use the words interchangeably:

  • Skip logic jumps a respondent past questions that don't apply. Answered "no" to "do you use integrations?" → skip the three integration questions. The paths rejoin; everyone ends at the same place.
  • Branching routes respondents down different question sets. Buyers get the buyer section, users get the user section. The paths may rejoin late or end differently.

The practical distinction: skip logic removes irrelevance from one shared survey; branching builds multiple sub-surveys behind one entrance. Skip logic is cheap to maintain — use it freely. Branching multiplies your testing and analysis surface — every branch is a sub-survey whose data you must analyse separately. Use it when respondent groups genuinely need different questions, not just fewer.

Which branching patterns cover real-world surveys?

Four shapes cover nearly everything we see in production:

Segment-by-screener. One early question ("which best describes you?") routes to per-segment sections, rejoining for shared closing questions. The workhorse of customer research. Keep it to 2–4 segments; beyond that, run separate surveys.

Score-dependent follow-up. The follow-up question depends on a rating's value — the NPS pattern: detractors get "what would you fix first?", promoters get the testimonial ask. The branch exists because the useful follow-up differs by sentiment.

Depth-on-interest. A flag answer opens an optional deep-dive: "you mentioned switching tools — two quick questions about that." Spend respondents' patience where their answers earned it; the funnel version of this pattern is identical.

Disqualify-and-exit. A respondent who fails screening exits early — politely, and immediately. Making a disqualified respondent answer eight more questions before telling them they don't qualify is how panels learn to lie to your screeners.

Whatever the shape: draw the flow before building it. On Formspring surveys, branching rules jump respondents per-answer without code — but the tool can only implement the tree you designed, and an undrawn tree is always wrong somewhere.

How do screening and quotas work together?

Screening decides who gets in: one to three opening questions that verify the respondent belongs to the population you are studying ("Have you bought project-management software in the last 12 months?").

Quotas decide how many of each kind get in: caps per segment that stop collection once a cell fills — 100 customers and 100 non-customers, 50 per company-size band. When a quota fills, further matching respondents get a polite full-quota exit.

Quotas exist because uncontrolled samples skew toward whoever is easiest to reach — your most engaged users, the chronically online, the people with grievances. If you analyse by segment, quota by segment, or one cell will starve while another overflows.

Two craft rules for screeners:

  • Hide the qualifying answer. "Do you own a dog? (we're surveying dog owners!)" recruits imaginary dogs — professional panel respondents are skilled at reverse-engineering screeners. Ask category questions with multiple plausible answers ("which of these do you have at home?") instead.
  • Screen on behaviour, not identity. "Which tools have you used in the past month?" out-screens "are you a marketer?" — behaviour is concrete, recent, and harder to aspirationally misreport.

And one honesty rule for quotas: report them. "n=100 per segment, quota-sampled" is a different claim from "we surveyed 300 customers", and your future self reading the chart needs to know which one is true.

What is answer piping, and when does it help?

Piping inserts a previous answer into a later question's text: the respondent says they use "Slack", and a later question reads "How satisfied are you with Slack?" rather than "…with the tool you mentioned".

Where it earns its keep:

  • Focus questions on a prior choice. Respondent picks their most-used feature from a list; subsequent questions name it. Sharper questions, sharper answers.
  • Confirmation of high-stakes details. "You said your team has 11–50 people — how many are involved in purchasing?" keeps the respondent and the survey aligned.
  • Personalised result screens in scored surveys and quizzes — "based on your answers about onboarding…" — the same mechanic that powers a quiz funnel's result screen.

Where it backfires: piping free-text answers verbatim (typos and profanity included) into question text, and piping so aggressively the survey feels like surveillance. Pipe choices, not essays; pipe to clarify, not to perform.

Where does randomisation fit in?

One more logic family worth naming, because it lives in the same settings panel: randomisation.

  • Option-order randomisation shuffles answer choices per respondent to neutralise primacy bias — on screens, the first options in a list get chosen more, regardless of content. Shuffle any list without a natural order (brands, features, reasons); never shuffle ordered scales, and pin "None of the above" to the bottom, exempt from the shuffle.
  • Question-block rotation varies the order of question groups across respondents so that fatigue effects spread evenly instead of always landing on the last section. Worth it on longer instruments where every section matters equally; overkill on a six-question pulse.

Randomisation is the cheapest data-quality logic there is — one toggle, no tree to maintain — and it pairs with, rather than competes against, the ordering discipline you applied at design time: deliberate order between topics, randomised order within arbitrary lists.

What are the common logic mistakes?

The five that account for most corrupted datasets we see:

1. Orphaned paths. A branch built for an answer option that was later reworded or deleted — respondents who pick the new option fall through to the wrong section, or to the end. Every edit to a question with logic attached requires re-walking every path. This is the survey equivalent of a dead link, except it silently destroys data instead of 404ing.

2. Logic on the wrong question. The branch keys on Q4 but the team later inserts a new Q4, shifting everything. Prefer tools that bind logic to the question itself rather than its position — and re-test after any reorder regardless.

3. Double-filtering. A question is skipped for segment B and analysed as if segment B answered it. The chart says "only 12% of enterprise customers use integrations" when enterprise customers were never asked. Every logic rule must be mirrored in analysis: filter the denominator to those who saw the question.

4. Branches that break comparability. Asking segment A "how satisfied are you?" and segment B "how happy are you?" then charting them together. If you intend to compare groups on a question, the question text and scale must be identical across branches — branch the context questions, share the measurement questions.

5. Untested trees. The survey ships after the happy path was clicked through once. Minimum bar: walk every terminal path end-to-end, plus the disqualify exits, plus one deliberately weird path (back-button mid-branch, changed screener answer). On any survey with more than three rules, write the test paths down — memory does not scale to trees.

A useful design ceiling from experience: if you cannot sketch the whole flow legibly on one sheet of paper, respondents will find the seams. Simplify the tree or split the survey.

The shape of survey logic that ships clean

  • Skip logic freely, branching sparingly, and only along lines you will analyse.
  • Screeners that hide the pass condition; quotas per analysis segment, reported with the results.
  • Piping for choices and confirmations, never raw free text.
  • Measurement questions identical across branches; context questions branched.
  • Every path walked before launch, and re-walked after every edit.

Logic done this way is invisible to respondents — the survey simply feels short and relevant — and that invisibility is the entire point.

Related from this desk