Generate personalized use cases

The version of personalized use cases that works for SEO is simpler than it sounds: a small form that sends each visitor to a page already built for their exact situation. You publish one page per valid combination of parameters, and the form acts as a router. Search engines reach those pages through links, and visitors arrive from Google or through the form.

How the pattern works on Derrick

Derrick’s form asks two things: the data you have and the data you want. Someone picks a LinkedIn profile URL as the input and the company’s industry as the output, and lands on a dedicated page explaining how to get an industry from a LinkedIn profile URL. Every page follows the same URL pattern:

https://your-site.com/use-case/{{output-data}}-from-{{input-data}}

I built 100+ page variations this way and integrated videos into them. In January 2025, two years later and with no additional SEO work, the pages still brought 88 clicks per day, about 3,000 per month, and 107 signups in a typical week. The numbers are in the Derrick case study.

It holds up because each page matches a precise task. Someone searching for a way to get a company name from an email knows what they want to do, and a page that does exactly that serves them better than a general feature tour. The same goes when an AI assistant is looking for a passage on that specific task. The form then catches the people already on your site who would never have typed that query.

Model inputs, outputs and valid combinations

Store inputs, outputs and their combinations in a database, and put the quality control in the combinations table. Say you sell a B2B data tool with 12 inputs and 30 outputs. On paper that makes 360 pages, but many of those pairs have no real answer, and a page explaining something your product can’t do has no reason to exist.

Here is the combinations table, shown with slugs in place of ids for readability:

Input	Output	Supported	Method	Example input	Example output
linkedin-profile-url	industry	true	Read from the company’s LinkedIn page	linkedin.com/in/jane-doe	Software
business-email	company-name	true	Resolve the email domain to the company	jane@acme.com	Acme
siret	address	true	Look up the French company registry	a 14-digit SIRET	Registered address
siret	personal-phone	false

The page list is then a query, and a combination with no method or no example simply doesn’t get published:

SELECT
  o.slug || '-from-' || i.slug AS page_slug,
  o.label AS output_label,
  i.label AS input_label,
  c.method,
  c.example_input,
  c.example_output
FROM combinations c
JOIN inputs i ON i.id = c.input_id
JOIN outputs o ON o.id = c.output_id
WHERE c.supported
  AND c.method IS NOT NULL
  AND c.example_output IS NOT NULL;

From there, a Python or Node.js script can create the pages, or you can sync the rows to a headless CMS such as Strapi or Contentful, or to a Webflow or WordPress collection.

Give each page something only it can say

Swapping two nouns in the same text is the thin pattern Google’s scaled content abuse policy, introduced in March 2024, is aimed at. If two pages would still read the same with their nouns removed, one of them shouldn’t exist. Here is what I make vary:

Page element	What changes	Where it comes from
Title, meta description, H1	“How to find {output} from {input}”	inputs, outputs
Where to get the input	Where this identifier is found and what format it takes	inputs
Method	Steps specific to this pair	combinations.method
Worked example	A real before and after	combinations.example_*
Limits	When this lookup fails and what to try instead	combinations
Video or screenshot	The procedure on this exact case	Media library
Related pages	Same input with other outputs, same output with other inputs	Query on combinations

The headings should follow a clean H1, H2, H3 order so the page reads logically. If you use AI on the text, feed it the fields above and have someone review a sample, because the facts must come from your data.

Use the form as a router

The form only needs two fields and a few lines of script. Make it easy to use on mobile, and generate the list of valid slugs from the SQL query at build time.

<form id="use-case-finder">
  <label for="input">I have</label>
  <select id="input" required>
    <option value="linkedin-profile-url">a LinkedIn profile URL</option>
    <option value="business-email">a business email</option>
    <option value="siret">a SIRET number</option>
  </select>

  <label for="output">I want</label>
  <select id="output" required>
    <option value="industry">the company's industry</option>
    <option value="company-name">the company name</option>
    <option value="address">the business address</option>
  </select>

  <button type="submit">Show me how</button>
</form>

<script>
  // Generated at build time from the combinations query
  const pages = new Set([
    "industry-from-linkedin-profile-url",
    "company-name-from-business-email",
    "address-from-siret",
  ]);

  document.querySelector("#use-case-finder").addEventListener("submit", (event) => {
    event.preventDefault();
    const input = document.querySelector("#input").value;
    const output = document.querySelector("#output").value;
    const slug = `${output}-from-${input}`;
    window.location.assign(
      pages.has(slug) ? `/use-case/${slug}` : `/use-case?missing=${encodeURIComponent(slug)}`
    );
  });
</script>

A pair with no page goes to the hub with a missing parameter. Log those values, since they tell you what visitors wanted and you don’t cover yet. Give the hub a canonical URL without the parameter so these visits don’t create duplicates.

Don’t count on crawlers to submit your form. Every page needs a plain <a href> path: a hub listing all use cases, plus the related links from the table above. Those “same input” and “same output” links form a natural internal linking structure. Add an XML sitemap regenerated with each publication so new pages get discovered quickly.

Where else this pattern applies

The test is whether you can list the parameter values in advance. If you can, each combination can be a page. If the value only exists once the user has typed it, you are building a tool, and the tool gets one good page.

Use case	Parameters	Best format
Pricing by segment	Company size, intended use	One page per segment
User guides	Skill level, goal	One page per pair
Educational content	Topic, learning goal	One page per pair
Sector marketing plans	Industry, objective	One page per pair, with channel recommendations specific to the sector
Travel itineraries	Destination, trip length	One page per pair
Training programs	Fitness level, objective	One page per pair
ROI calculators and price estimators	The user’s own numbers	One tool on one page, plus preset scenarios only if their defaults really differ
Product recommendations	Preferences, browsing behavior	Component on existing pages, no new URLs
Adaptive journeys	Interactions on the site	Product logic, outside your SEO plan

Measure combinations, then widen the matrix

In Search Console, filter by URL pattern to see which generated pages get impressions and which ones deserve work. Mixpanel or Google Analytics will show behavior and conversion on those pages, including form submissions. Server logs tell you which pages Googlebot visits often and which it ignores, and an ignored group usually points to a linking problem. The tracking chapter goes into the setup.

Your next step: write down your two parameters, list their values, and mark the pairs where you have a real method and a real example. Build ten of those pages with the full set of elements above and read them side by side. If they feel distinct, generate the rest and add the form.