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

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:

1. Win the PAA box itself — Google pulls answers from pages that directly address the question
2. Rank for long-tail variations — each PAA question maps to dozens of similar queries
3. Increase time on page — comprehensive FAQ sections keep users engaged
4. Discover new comparison angles — 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("\n")}

    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?" → new comparison opportunity
• "How does Purple compare to Tempur-Pedic?" → might already exist, but validates demand
• "Which robot vacuum is best for pet hair?" → 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:

1. Extract PAA questions from SERPs
2. Generate data-backed answers
3. Add to comparison page with FAQPage schema
4. Google surfaces our answers in PAA boxes
5. More visibility → 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.

Try It

Check any comparison page on aversusb.net — the FAQ sections are largely PAA-driven. View source to see the FAQPage schema wrapping each answer.

---

Part 7 of our "Building SmartReview" series. Previous: Part 6: ISR and On-Demand Revalidation