If you’ve ever tried to run B2B surveys, you know the pain: endless qualifiers, complex branching, and the constant fear your “logic” will send a CEO to a question about TikTok usage. If you’re using Appinio and need more than a basic “skip to next,” this guide’s for you. I’ll walk you through how to make Appinio’s logic work for real B2B research—without falling into the usual traps.
Why Custom Logic Matters in B2B Surveys
If you’re dealing with B2B, “one size fits all” never really fits anyone. You’ve got different company sizes, industries, job roles, maybe even regions or budgets. You need to segment, qualify, and route people so you don’t waste their time (or your own).
Appinio has a reputation for being fast and user-friendly, but when you need tailored logic—think: quota splits, deep profiling, or dynamic question paths—you have to dig a bit deeper. The basics work, but you’ll need to finesse the details. Here’s how.
1. Map Out Your Logic Before Touching the Tool
Pro tip: Don’t start in Appinio. Grab a whiteboard, spreadsheet, or even a napkin. Map out:
- Who should see what? (By company size, role, industry, etc.)
- Which questions are “must ask,” and which are conditional?
- Where should respondents exit (screen out) if they’re not a fit?
- Do you need quotas or soft caps?
Why bother? Appinio’s logic editor is decent, but it’s easy to lose the thread if you haven’t planned. You don’t want to realize halfway through that you’ve built a logic pretzel.
2. Build Your Screener Questions First
Screeners are your gatekeepers. In B2B, these are usually:
- Company size
- Industry/vertical
- Job function/decision-maker status
- Location or region
Set these up as the very first questions. Use single- or multi-select, not open-ended. Appinio’s logic only works off structured responses.
What works:
- Setting up “disqualify” logic right away—Appinio lets you flag certain answers as screen-outs.
- Keeping screeners short and clear. If people get confused, your logic won’t matter—they’ll just leave.
What doesn’t:
- Over-complicating screeners. Don’t try to qualify on every possible variable up front. You’ll lose good respondents.
3. Use Branching Logic (Skip Logic) to Route Respondents
Now, the meat of it: Appinio’s branching (skip) logic. This lets you send people to different questions or sections based on their answers.
How to do it in Appinio
- In the survey builder, click on a question.
- Find the “Logic” or “Branching/Skip Logic” option.
- Set rules like: “If Q2 = ‘Finance’, go to Q5; if not, go to Q3.”
Pro tips:
- Keep your logic simple. If you have more than two branches per question, check your survey map—are you overcomplicating?
- Test every branch. Appinio’s preview mode is your friend, but it won’t catch every dead end.
- Use clear, unique question names (“Q2: Industry”) so you don’t mix up logic later.
What to ignore:
- Nested logic three layers deep. Appinio’s interface isn’t built for heavy-duty, programmatic logic. You’ll end up with a mess.
4. Set Up Quotas and Caps (If Needed)
A lot of B2B projects need quotas—for example, “at least 50 responses from IT, 30 from HR.” Appinio supports quotas, but it’s not as flexible as some research platforms.
How to set quotas in Appinio
- Go to the “Targeting” or “Quotas” section (usually after you set up questions).
- Add your quota splits: by industry, region, or whatever matters.
- Set hard caps (e.g., max 50 for IT) or soft caps if Appinio allows.
Heads up:
- Appinio’s quota logic is simple. Don’t expect nested quotas (e.g., “25 from IT in Germany, 25 in the UK, and both must be decision-makers”). For that, you’ll need to hack it with screener logic or use another tool.
- If you need really granular quotas, consider running multiple surveys or exporting data to filter later.
5. Use Piping and Dynamic Text—Sparingly
Appinio lets you “pipe” answers from earlier questions into later ones (e.g., “You said your company is in [Industry]…”). It’s handy for personalized surveys, but don’t go overboard.
How to use piping
- In the question text, insert a placeholder for the earlier answer (Appinio usually shows a menu).
- Double-check in preview mode—sometimes piped text breaks if respondents skip a question.
What works:
- Piping company size, industry, or job title into follow-up questions for clarity.
- Using dynamic text to confirm what the respondent told you (“Earlier, you said…”).
What to avoid:
- Piping open-ended text. If someone enters “asdasd” for their industry, it’ll show up as “You said your company is in asdasd…” Not a good look.
- Over-personalizing. It slows down survey programming and won’t boost data quality.
6. Test Every Path (and Break It on Purpose)
This is where most B2B surveys fall apart—logic that works in theory but not in practice.
How to test
- Use Appinio’s preview to run through every possible branch.
- Try to “break” the survey: answer in ways you think no one will, to see if you hit dead ends.
- Ask a colleague to test with “weird” answers.
What works:
- Keeping a checklist of all the paths you mapped out in step 1.
- Checking quotas: make sure they close out as expected.
What doesn’t:
- Trusting that if it works once, it’ll work every time. Edge cases sneak through.
7. Clean Up Your Survey (and Your Logic Map)
Before you launch:
- Remove any unused questions or logic branches.
- Double-check the labels and logic rules—typos here can kill data quality.
- Export your logic map or flowchart (if you made one) to keep for next time.
Why bother? Clean surveys mean cleaner data, fewer headaches, and less apologizing to clients later.
What Appinio Does Well (and Where It Struggles)
Works well for: - Simple to moderately complex branching (skip logic, basic quotas). - Fast B2B fieldwork with clear segmentation. - Visual logic editing for straightforward surveys.
Falls short for: - Deeply nested, multi-variable logic (e.g., “If A and B but not C, show X”). - Complex multi-level quotas. - Heavy use of randomization or advanced logic customization.
If you need true “programmatic branching,” or if your survey looks like a subway map, you’ll hit limits fast. For most B2B projects, though, Appinio covers 80% of needs if you keep logic under control.
Keep It Simple—Then Iterate
Custom survey logic can save you from garbage data, but it’s easy to let things spiral. Start simple, test hard, and don’t get clever just for the sake of it. If you hit a wall in Appinio, ask yourself: do you really need that complex routing, or are you overengineering?
The best B2B surveys don’t try to do everything at once. Build, launch, learn—then tweak. Your sanity (and your respondents) will thank you.