Imagine you’re managing a chatbot for your NGO. Your organization needs to share learning content regularly via your chatbot. That is, every week you send the same thing: a description and a 5-question quiz. So you build a new flow every week. By the end of the year, you have 50+ flows!

Or maybe users reach out to your chatbot and pick a topic from a menu—health, finance, agriculture. When they pick a topic, they get a video followed by a short task description for that topic. Same structure every time. Different content for each topic. Add a new topic? Build another flow.

All identical. Just different content.

What if we told you there’s a better way? And it’s simpler than you think.

Let’s dive in.

The Problem: Flow Sprawl and the Hidden Costs

Here’s the thing—building flows isn’t hard. It’s maintaining them that costs you.

You’re running a program with recurring content. Every week you want to send out a new activity. A short description followed by a 5-question quiz. Same structure every time. Different content.

So you build the first flow and it works. Next week? You copy it, change the content, deploy. Week 3? Copy again. Week 4? Copy again.

They’re basically identical. Just different content in each.

Or maybe you’ve got a main menu where users can select information on different topics—health, finance, agriculture. When they pick a topic, they get a video followed by a short task description for that topic. So you build one flow per topic. Add a new topic? Build another flow. The logic is the same every time; you’re just repeating yourself.

Either way, something happens. Maybe a bug. Maybe you want to tweak the flow logic. Or you realize the quiz should have 6 questions, not 5.

Now you’re on your flow builder, hunting through dozens of flows, making the same change in multiple places. Miss just one, and you’re left wondering which flows were updated, which weren’t, and where the issue is coming from.

This is the trap. The building part was quick. But now you’re stuck managing this sprawl of almost-identical flows. Updates are scattered. Changes are error-prone. Scaling feels impossible.

You can see the pattern repeating in your head, but you’re stuck building the same thing over and over.

The Solution: One Flow, Many Contents

What if you didn’t have to do that?

What if one flow could handle all of it? 

Every time your bot needs to send content with a recurring structure—whether it’s triggered by time, user action, or anything else—it fetches the relevant row from the Google Sheet and sends it. From that point on, content management happens entirely in the sheet. Adding new content is as simple as inserting a new row. Updating existing content is as simple as editing a cell. The flow stays untouched—no rebuilding, no copying, and no manual updates every time your content changes.

The flow and the content are decoupled. The flow determines how and when content is sent, while everything else lives in the Google Sheet.

The Basic Pattern

Your Google Sheet becomes your content database. Your flow becomes your delivery mechanism.

Here’s how it works:

Your Google Sheet has:

• One special column called key — a unique identifier for each row. This can be a number (e.g., 1, 2, 3… for weekly activities) or text (e.g., topic names or definitive user-selected options). The only requirement is that each key is unique.
• Other columns for your recurring data. This can include content sent to users (titles, videos, questions, options, etc.) as well as values the flow uses for logic (such as the correct answer to a quiz question or other comparison values).

Your Flow has:

• At the start of the flow, a step called Read from Sheet. The step looks up a specific row in your Google Sheet using the key you provide, then fetches all the data from that row for the flow to use.

When your flow runs, it says: “Read the sheet and give me the row where key = 1” (or key = 2, depending on what you need). The g-sheet finds that row because the key is unique, returns that entire row—all the columns, all the content. The flow then uses that data.

Two Examples: Where this pattern works

The easiest way to understand this is through examples. Let’s walk through two common use cases to see what this looks like in practice.

Example 1: Weekly Recurring Content (Push-Based)

You’re sending out a learning activity every week. Title, description, then 5 multiple-choice questions. Same structure. Different content each week.

Normally: Week 1 → Week 2 → Week 3 → … → Week 52. That’s 52 flows.

With Google Sheets: One flow.

In this example, each row represents one week’s activity, while each column stores a specific piece of recurring content. It would look something like this:

Example 2: User-initiated content fetch (Pull-Based)

Your bot has a menu: “Pick a topic: Health, Finance, Agriculture, Education.”

User picks “Finance”. They get finance-related Q&A. User picks “Health”. They get health-related Q&A.

Normally: One flow per topic = 4 flows. Add a fifth topic? Build another flow.

With Google Sheets: One flow.

Your sheet is structured by topic:

Why this actually matters

The power is in how you scale—without multiplying flows.

Scenario 1: New Content (Same Structure)
Add a new week of activities? Add a row. Add a new topic? Add a row. Edit an existing week’s content? Update the cells in that row.

The flow executes the same operations regardless of which row it reads. It’s built to handle any data you give it.

Scenario 2: Expanding the Structure
Want to add more quiz questions? Update the sheet with additional columns and make a minor tweak to the one flow that dictates the logic. That’s it. No rebuilding, no duplicating.

The Real Payoff:
Your content and structure stay organized in a sheet. Someone on your team can update content without touching the flow builder. The flow only changes when the core logic changes—and that happens to just one flow.

Compare this to the old way:

• 50+ weeks of content = 50+ flows to manage
• Add more quiz questions = rewrite all 50+ flows
• Change a bug = fix 50+ flows

Now? One flow. Scaling happens in the sheet, with minor revisions to only one flow where the delivery logic lies. No flow multiplication. No flow maintenance burden.

Your flow builder stays clean. Growth happens in the spreadsheet, not scattered across multiple flows.

Implementation Walkthrough: From G-Sheet to Live Flow on the Glific Platform

Let’s walk through setting up topic-based content—where users select a topic (like Health, Finance, or Agriculture) and the flow pulls in a question with multiple-choice options, then checks their answer. Here’s how it comes together end to end.

Create a Google Sheet with columns:

• key — the topic name (e.g., Health, Finance, Agriculture)
• question_1 — the question for that topic
• option_1, option_2, option_3 — the text that is fed into the buttons as options
• q1_correct_answer — the correct option, used by the flow to check the user’s response

Link this sheet into the Glific Platform with “Read from Sheet” permissions. To understand how to in configure this, head to Glific’s documentation.

Once your sheet is structured, the next step is wiring it into your Glific flow.

The flow then fetches the question and options from that row, and compares the user’s reply against q1_correct_answer to show whether the option selected is correct/incorrect.

Adding a new topic later is as simple as adding a new row—no need to touch the flow. Want more questions per topic? Add more columns (question_2, option_2a, etc.), with slight tweaks to the main flow to pull values from the new columns.

Getting Started

The setup is straightforward:

1. Create your Google Sheet with your key column and content columns. Organize it based on your use case (weekly content or topics).
2. Structure it accurately with consistent column names, unique keys, same structure for each row.
3. Build your flow to use the Read from Sheet operation with your key.
4. Map the data to your flow nodes using the column names.
5. Update the g-sheet when you have new content with minor tweaks (if applicable) on only one flow.

The real payoff

Here’s the core insight: Your Google Sheet is your content database. Your flow is your delivery template.

Stop building flows for each piece of content. Instead, build one flow that knows how to read from your g-sheet and send it out.

If you see yourself copying and pasting flows where only the content changes? That’s your signal. It’s time to move that content to a g-sheet.

It sounds like a small thing. But when you’re managing 50+ flows, suddenly being able to update content from a g-sheet instead of editing flows? That changes everything.

Your flow builder stays clean. Your content stays organized. Scaling becomes something you want to do instead of something you dread.

That’s the elegance of it. When only your content changes, your flow shouldn’t have to.