What is a subquestion?

A subquestion is a follow-up question that appears only when a person answers its parent question in a specific way. Instead of showing every possible field at once, the form stays compact: subquestions show up only when they're needed, and their options adapt to the answer above them. Think of it as a question inside a question.

A subquestion stays completely hidden until its parent question is answered. If you preview your form and the subquestion isn't there yet, that's expected behavior, not a bug. It appears once the parent question has an answer.

Why subquestions are useful

Say someone orders a "drink." That answer triggers a new question to specify the type of drink ("Coke," "Water," or "Ginger Ale"), which triggers another question about the size ("Bottle" or "Can"). If they'd picked "dessert" instead, different follow-up questions would appear. Without subquestions, every one of those fields would sit on the form at once, making it harder to fill out.

What you need

To set up subquestions, you need a spreadsheet with two tabs:

Form questions contains the form questions. Your form fields connect to this tab, and responses are recorded here too, as explained in Create a new Sheetgo Form.
Parameters holds the values your form fields use to populate the subquestions.

We'll use the restaurant example throughout.

Step 1: add the primary question to the Form questions tab

Create a new column for your primary question, and use the field title as the column header.
Format the primary question column with data validation, and add the list of values people can choose from.

In our example the primary question is "Order Item Type," with data validation covering the values "Drinks," "Sandwich," "Burger," and "Dessert."

This setup creates the initial list of questions in your form. Next, configure the subquestions in the Parameters tab.

Step 2: list every combination in the Parameters tab

The Parameters tab lists all potential combinations of values for your primary question and its subquestions.

The conditional range you'll point at in step 3 is a two-column list: the parent question's answers go in the first column, and the options to show for each answer go in the second.

Create one column for the primary question and another for the subquestion, then list every possible combination as its own row. If someone selects "Drinks" from the primary question, list each drink option on its own row: "Coke," "Water," and "Ginger Ale." Repeat this for each value of your primary question.

You can keep adding columns for additional subquestion levels, which also makes the table easier to filter by item and sub-item.

Please note: you must list every possible combination of values as new rows. If a combination is missing, people may run into issues when filling out your form.

You can also create a separate table for each set of parameters instead of one long table (a table for "Drinks" values, a table for "Dessert" values, and so on). Keep in mind this changes how you configure your form questions in the next step.

Step 3: adjust the headers in the Form questions tab

With your parameters listed, return to the Form questions tab and add the subquestion configuration to the headers.

"Order Item Type" is the column you created in step 1. It's the independent field, and the first subquestion (Item) depends on its answer.

Add these configurations to each subquestion header, in this order:

conditional sets the relationship with the primary question column. Its value must be the exact name of the parent column, or the column letter (Column C in this example). Using the letter keeps the configuration short and lets you rename headers freely.
range links the lookup data in the Parameters tab. In this example it covers the "Type" and "Item" columns, which pair each parent answer with its options. This works much like a vlookup.

Quote the range value whenever the tab name contains a space, for example range:"Form responses!A2:B". Quoting is always safe, so add it whenever you're unsure. Parameters has no space, so it works either way.

At this point, the configuration looks like this:

Item [conditional: Order Item Type, range: Parameters!A2:B100]

text added at the end lets the field accept any typed answer. If the typed value matches one of the listed options, the form accepts it and shows the option as expected.

Item [conditional: Order Item Type, range: Parameters!A2:B100, text]

Here's the same pattern in a compact example: a City question that shows options based on the Country answer.

City [conditional: Country, range: "Options!A2:B"]

Repeat these steps for however many subquestions your form needs. Once you're done, the spreadsheet is ready: whenever a person selects a value in "Order Item Type," their answer triggers the next subquestion field, where they can continue selecting answers.

Is there a limit on subquestion levels?

No, there's no limit. You can add as many subquestion levels as you need, as long as each answer should influence the next question.

In the restaurant example, the chain goes from Order Item Type to Drink to Size. You could extend it with Temperature, then Add-ons, then anything else that depends on what came before. Each new level adds:

One column in the Form questions tab, with its own conditional and range configuration.
One column in the Parameters tab, where each row lists a valid path through the chain.

The longer the chain, the more rows the Parameters tab needs. A 3-level chain with 4 options per level produces dozens of rows. Add two more levels and you're looking at hundreds, so it's worth grouping options and pruning combinations you don't actually need.

Supported data types for subquestions

In the examples below, anything in angle brackets (like <ParentField>) is a placeholder: replace it with the actual name or range from your sheet. The square brackets [ ] are part of the configuration and must be typed as shown.

Subquestions in Sheetgo Forms can validate input with these types:

dropdown shows a preset list of options defined in a separate tab (the examples above use this).
text accepts any text value.
email requires a valid email format.
number accepts numeric input only.
date asks for a valid calendar date.
time takes a time in HH:MM format.
datetime takes a date and a time together.
regex validates text against a custom pattern.

Configure each data type

Every subquestion uses the same base format:

[conditional: <ParentField>, range: <LookupRange>, <OptionalFieldType>]

With Order Item Type as the parent field and Parameters!A2:B100 as the lookup range, a text subquestion looks like this:

[conditional: Order Item Type, range: Parameters!A2:B100, text]

Here's the syntax for each type:

[conditional: <ParentField>, range: <LookupRange>, text]
[conditional: <ParentField>, range: <LookupRange>, email]

Tip for email fields: add default:email so the field pre-fills with the person's email address while staying editable.

[conditional: <ParentField>, range: <LookupRange>, number]
[conditional: <ParentField>, range: <LookupRange>, date]
[conditional: <ParentField>, range: <LookupRange>, time]
[conditional: <ParentField>, range: <LookupRange>, datetime]
[conditional: <ParentField>, range: <LookupRange>, regex: <YourPattern>]

Both <ParentField> and <LookupRange> are required for subquestions to work correctly:

<ParentField> tells the form which main question the subquestion depends on.
<LookupRange> defines which values appear based on the parent's selected answer.

Without those two elements, the conditional logic can't be applied. The type is optional: if you omit it, the subquestion defaults to a dropdown using the values in your Parameters range.

Use auto-fill

Auto-fill completes a field automatically based on a previous answer.

Configure it with default:vlookup plus two companion configurations, key and range. key names the field that provides the value to search for, so its value is the exact name of that other field. range points at the data: the first column must hold the searched value, and the following columns hold the values related to it.

Using this example, a pre-filled field can be configured like this (the tab name contains spaces, so the range is quoted):

[default:vlookup, key: "User id", range: "Auto fill parameters!A2:B"]

Here an existing field called User id has options from 1 to 6. When that field changes, the pre-filled field updates its default value to match.

You can also add an index to choose which column of the range shows in the form. The index starts at 1 and can go up to the number of columns in your spreadsheet.

For example, if the range were "Auto fill parameters!A2:C", which includes the Color column, and you want to display the values from the Name column, add index:2. If you don't set an index, the form uses the last column of the range.

Subquestion not appearing? Open the chat in the bottom-right corner of this page and send us your header text and the Parameters range. We'll take a look.

Configure subquestions for Sheetgo Forms