Build a Content Idea Backlog From Reader Questions and Search Data
Back to Blog
Content Strategy· 9 min read

Build a Content Idea Backlog From Reader Questions and Search Data

A sustainable idea backlog is a maintained list with evidence, a decision per row, and a review habit. Learn what each row should hold, how to deduplicate, and when to refresh instead of publish.

ML
By Mneme Labs
NEPA AI · Building autonomous systems for creators and businesses
#content ideas#editorial planning#Search Console#content refresh#AI workflow

Most "never run out of ideas" advice is a prompt that produces a long list once. The list feels useful for a week. Later, you notice overlapping topics, poor audience fit, and items with no record of why they were added.

A backlog works differently. It is a living list where each row carries its evidence, a decision, and a review date. AI helps with sorting, clustering, and drafting questions in a reader's words. A generated list alone is not evidence that someone wants the article. That has to come from your own site data, reader messages, and the pages you have already published.

This is a different job from a one-off brainstorm. If you want a fast batch of candidates to feed the backlog, the matrix exercise for blog post ideas covers that. Here the focus is what happens to an idea after it exists.

What a backlog row should hold

Keep the schema small enough that you will actually fill it in.

{
  "id": "2026-11-014",
  "question": "Why are my tomato leaves curling?",
  "evidence": {"type": "search-console-query", "note": "Appears in query export, 30 days", "link": ""},
  "existing_page": "/blog/tomato-leaf-problems",
  "decision": "refresh",
  "reason": "Page covers yellowing but not curling",
  "fit": "core",
  "review_on": "2026-12-15"
}

The fields do specific jobs:

  • question is written the way a reader would ask it, not as a keyword.
  • evidence says where the idea came from. "The model suggested it" is a source of candidates, not evidence of demand.
  • existing_page forces the duplicate check before any writing starts.
  • decision is one of four values: new, refresh, merge, skip.
  • review_on stops the list from becoming a graveyard.

If you generate rows with a model, use a structured output feature so every row has the same fields. OpenAI's Structured Outputs guide says the feature constrains output to your JSON Schema, and also says your application still has to handle refusals, incomplete responses, and business rules the schema does not express. A well-formed row is not a correct row.

Three sources that deserve a row

Search queries. Google's Performance report help page lists clicks, impressions, click-through rate, and average position, and lets you group results by query or page. It also notes that a query appearing in the list does not mean you will see your site when you search it yourself, because results depend on time, place, device, and search history. Treat a query as a signal that people looked and your site was in the mix, not as proof that a page would win.

Reader questions. Emails, replies, comments, and support threads show the wording and the situation behind a question. Use them only if readers agreed to be quoted or analyzed, and strip names and contact details before pasting anything into a model. The audience research guide covers consent and thresholds in more detail.

Existing posts. Pages that rank for a query but do not answer it fully, or that describe something that has changed, are often a better use of a day than a new article.

Google's guide to using Search Console and Google Analytics together cautions that the tools measure different things. It points to Search Console clicks and Analytics sessions as the most comparable pair, and says their numbers will not match exactly. Do not build a decision on a small gap between them.

Decision tree that routes an idea to new post, refresh, merge, or skip depending on whether a live page answers it, whether it fits the site, and whether there is real detail to add
One outcome per idea. Most of the work is deciding what not to publish.

A worked example

The data below is invented to show the process. Imagine a small home-garden blog with about forty posts. This month's intake has five rows:

  1. A query export shows "tomato leaves curling" with impressions and almost no clicks. A post on tomato leaf problems exists but only discusses yellow leaves. Decision: refresh the existing post with a section on curling, after checking the cause against a university extension source.
  2. A reader emails asking when to sow carrots in a cold climate. No post covers it, and you have grown carrots there for years. Decision: new post, because you can add first-hand detail.
  3. A model suggests "10 trending garden hacks." No evidence, no reader, and it is the sort of page that exists only because a topic is popular. Decision: skip.
  4. A query matches both a pruning post and a staking post. Readers likely want one answer. Decision: merge into a single page and plan a redirect.
  5. A reader asks about hydroponic lettuce. Your site is about soil gardening and you have no experience. Decision: skip. An honest "not our topic" beats a thin page.

Notice that two of five rows touch existing pages and two end in skip. Your own mix will differ.

Deduplication is the part people skip

A model will cheerfully suggest a topic you published last spring. Before any idea becomes a row, compare it with your existing titles, your last few months of drafts, and the other rows in the backlog. Start with something cheap and deterministic:

import re
from difflib import SequenceMatcher

STOP = {"the", "a", "an", "to", "of", "how", "do", "i", "my", "is",
        "for", "in", "on", "and", "can", "you"}

def norm(text):
    text = re.sub(r"[^a-z0-9 ]", " ", text.lower())
    return " ".join(w for w in text.split() if w not in STOP)

def near_duplicates(candidates, existing_titles, threshold=0.7):
    flagged = []
    for cand in candidates:
        for title in existing_titles:
            score = SequenceMatcher(None, norm(cand), norm(title)).ratio()
            if score >= threshold:
                flagged.append((cand, title, round(score, 2)))
    return flagged

A local check of this snippet used two existing titles ("How to prune tomato plants" and "Why are my tomato leaves curling?") and three candidates. It flagged "How do I prune my tomato plants?" as a match and missed "Tomato leaf curl: causes," which asks the same question as the second title. Wording-based matching catches copies and misses paraphrases.

For paraphrases, ask a model to group candidates by the question they answer, then check each group yourself. Embedding similarity is another option. Either way, treat the tool as a way to surface suspects. A person confirms the merge, because "same question" is a judgment about readers, not about text similarity.

Refresh or publish

Google's people-first content guidance lists warning signs that apply directly to backlog habits: writing about something only because it is trending, changing a page's date to look fresh when the content has not substantially changed, and producing lots of content on many topics hoping some performs. A refresh should change something a reader can notice, such as a corrected step, a new example, or a removed section. Update the date only when that is true.

The same page asks whether an existing or intended audience would find the content useful if they came to your site directly. That makes a good fit test for every row: is this a question your readers have, and do you know something about it?

Google's guidance on generative AI content says AI can help with research and structure, and warns that using it to generate many pages without adding value may violate its policy on scaled content abuse. A backlog full of model-suggested titles that all become articles is the pattern that guidance describes.

Keeping it alive

Four-step loop of collect, triage, publish or refresh, and review, with a suggested weekly triage and monthly review
A suggested rhythm. Adjust the cadence to how often your site gets new questions.

A simple rhythm: add new queries and reader questions as rows when they arrive, triage weekly, and review monthly. During review, compare what happened against the reason you chose the row. If you refreshed a page because you believed it was incomplete, check whether the queries and reader replies changed. Prune rows older than a few months that never earned a decision.

Failure modes

  • A growing list nobody reads. Cap the number of open rows. If it grows faster than you triage, intake is too loose.
  • Evidence that is really the model's opinion. Require a link or a note for every row.
  • Chasing every query. Impressions with no clicks might mean the page is wrong, or the query is not yours to win.
  • Merging too eagerly. Two similar questions can need separate answers if the readers differ.
  • Dated pages left alone. Add a review date to your highest-traffic posts, not just new ideas.

Limits

Search data tells you what people typed, not why. Small sites have small numbers, and a handful of impressions is a lead to check, not a trend. The example above is invented, and your own ratios of new posts to refreshes will vary. None of this guarantees traffic. It reduces wasted writing.

Next step

Open your current idea document. Add the four columns that matter (question, evidence, existing page, decision) and fill them for the ten most recent ideas. Flag duplicates and unsupported rows for review instead of turning every candidate into an assignment. For the planning layer above the backlog, the 90-day content calendar guide is a place to continue, and the content drip guide covers scheduling approved work.

Sources

Images are original Mneme Labs diagrams.