How We Use "People Also Ask" to Generate 40% of Our Comparison Content Ideas

Daniel Rozin

Google's "People Also Ask" (PAA) boxes are one of the most underused content discovery tools in SEO. For product comparison sites, they're a goldmine.

At SmartReview, PAA data drives roughly 40% of our new content ideas. Here's how we systematically extract, score, and turn PAA questions into high-performing comparison and FAQ content.

Why PAA Matters for Comparison Sites#

When someone searches "AirPods Pro vs Sony WF-1000XM5," Google typically shows 4-8 PAA questions like:

"Are AirPods Pro better than Sony for phone calls?"
"Which has better noise cancellation, AirPods or Sony?"
"How long do AirPods Pro last compared to Sony?"
"Is Sony WF-1000XM5 worth the price?"

Each of these represents a real user question with search demand. And here's the key insight: answering these questions on your comparison page helps you:

Win the PAA box itself u2014 Google pulls answers from pages that directly address the question
Rank for long-tail variations u2014 each PAA question maps to dozens of similar queries
Increase time on page u2014 comprehensive FAQ sections keep users engaged
Discover new comparison angles u2014 PAA reveals what users actually care about

Our PAA Extraction Pipeline#

We extract PAA data from every SERP we monitor using the DataForSEO API:

interface PAAItem {
  question: string;
  sourceUrl: string;
  sourceTitle: string;
  snippet: string;
  position: number;  // position in the PAA box (1-8)
}

async function extractPAA(keyword: string): Promise<PAAItem[]> {
  const response = await dataforseo.post(
    "/serp/google/organic/live/advanced",
    [{
      keyword,
      location_code: 2840,
      language_code: "en",
      device: "desktop",
    }]
  );

  const items = response.tasks[0].result[0].items;
  return items
    .filter((item: any) => item.type === "people_also_ask")
    .flatMap((paa: any) => paa.items.map((q: any, i: number) => ({
      question: q.title,
      sourceUrl: q.url,
      sourceTitle: q.source,
      snippet: q.snippet,
      position: i + 1,
    })));
}

Scoring PAA Questions#

Not all PAA questions are worth targeting. We score them on three dimensions:

1. Comparison Relevance#

Does the question involve comparing two products?

function isComparisonQuestion(question: string): boolean {
  const patterns = [
    /better than/i,
    /compared to/i,
    /vs\.?\s/i,
    /versus/i,
    /difference between/i,
    /which (is|should|has)/i,
    /or\s+\w+\s*\?/i,  // "X or Y?"
  ];
  return patterns.some(p => p.test(question));
}

2. Answerability#

Can we answer this with structured data we already have?

function getAnswerability(question: string, comparison: ComparisonData): number {
  const attributes = comparison.attributes.map(a => a.name.toLowerCase());
  const questionLower = question.toLowerCase();
  
  // Check if question maps to a known attribute
  const matchedAttributes = attributes.filter(attr => 
    questionLower.includes(attr) || 
    synonymMap[attr]?.some(syn => questionLower.includes(syn))
  );
  
  return matchedAttributes.length > 0 ? 1.0 : 0.5;
}

3. Content Gap#

Are we already answering this question on the page?

function isContentGap(question: string, existingFaqs: string[]): boolean {
  return !existingFaqs.some(faq => 
    stringSimilarity(question, faq) > 0.7
  );
}

The combined score determines priority:

const priority = 
  (isComparisonQuestion(q) ? 3 : 1) *
  getAnswerability(q, comparison) *
  (isContentGap(q, existingFaqs) ? 2 : 0.5);

Turning PAA Into Content#

Once scored, PAA questions flow into two content streams:

Stream 1: FAQ Enrichment#

High-scoring questions get added to existing comparison pages as FAQ items. We generate answers using our enrichment pipeline:

async function generateFaqAnswer(
  question: string,
  comparison: ComparisonData
): Promise<string> {
  // Pull fresh data relevant to the question
  const context = await tavily.search(
    `${question} ${comparison.entityA.name} ${comparison.entityB.name}`,
    { searchDepth: "advanced" }
  );

  // Generate a concise, factual answer
  const answer = await claude.generate({
    prompt: `Answer this product comparison question concisely (2-3 sentences).
    
    Question: ${question}
    Product A: ${JSON.stringify(comparison.entityA)}
    Product B: ${JSON.stringify(comparison.entityB)}
    Recent context: ${context.results.map(r => r.content).join("
")}
    
    Rules:
    - Be specific with numbers and specs
    - Name a winner if one exists
    - Cite the key differentiating factor`,
  });

  return answer;
}

Stream 2: New Comparison Discovery#

PAA questions sometimes reveal comparison pairs we haven't covered:

"Is Dyson V15 better than Shark Navigator?" u2192 new comparison opportunity
"How does Purple compare to Tempur-Pedic?" u2192 might already exist, but validates demand
"Which robot vacuum is best for pet hair?" u2192 category roundup opportunity

We extract entity pairs from these questions and feed them back into our keyword discovery pipeline.

The FAQPage Schema Connection#

Every FAQ answer we generate gets wrapped in `FAQPage` JSON-LD schema (covered in Part 4). This creates a direct feedback loop:

Extract PAA questions from SERPs
Generate data-backed answers
Add to comparison page with FAQPage schema
Google surfaces our answers in PAA boxes
More visibility u2192 more data on what users ask

Results#

After 3 months of PAA-driven content enrichment:

40% of new content ideas originated from PAA extraction
PAA box appearances increased 3x (from ~200 to ~600 keywords)
Organic CTR improved 18% on pages with PAA-optimized FAQ sections
Average FAQ section grew from 3 to 7 questions per comparison page
Long-tail keyword coverage expanded 45% without creating new pages

The most surprising finding: PAA questions often reveal user concerns that aren't obvious from keyword data alone. "Are AirPods safe for kids' ears?" would never show up in a keyword tool, but it's a real question that real buyers ask.