KentLundin.com

Designing a website is more than picking menus and URLs. The best sites are organized around entities (the real-world things your content is about) and a knowledge graph (how those things relate). This approach gives search engines confidence in what your site covers and helps generative engines assemble accurate, useful answers that cite you.

1) Why Structure Matters for SEO and GEO

SEO (Search Engine Optimization):
Clear structure improves crawlability and discoverability. A logical hierarchy concentrates internal links on your most important pages (pillar pages), clarifies topical coverage, and reduces duplicate/competing pages. Schema markup and consistent naming help search engines disambiguate entities (e.g., “R Mountain” the butte near Rexburg vs. other “R Mountain” trails).

GEO (Generative Engine Optimization):
Generative engines (ChatGPT, Perplexity, Gemini, etc.) build answers by connecting entities. A site that explicitly models entities and relationships (with internal links and schema) becomes an easy source to quote and synthesize: the engine can trace “what is this,” “how is it related,” and “where’s the supporting page.” Good structure reduces hallucination and increases the chance your content is selected, summarized, and linked.

2) Let Entities Guide Main Pages and Subpages

Start with a core entity that defines your site’s purpose (e.g., “Rexburg Hiking Trails Guide”). From there, list related entities and attributes:

• Entity types: Trail, Trailhead, Park/Area, Map, Safety Topic, Seasonal Condition, Wildlife, Gear.
• Attributes: Distance, Elevation gain, Difficulty, Family-friendly, Dog policy, Best season, Land manager, Parking/Fees, GPS coordinates.

Translate that inventory into pages:

• Pillar (main) pages map to broad, high-value entities or intents (e.g., “Rexburg Hiking Trails” overview; “Beginner-Friendly Trails near Rexburg”).
• Cluster (sub) pages map to specific entities (e.g., an individual trail) or a tight attribute/theme (e.g., “Wildflower Hikes in June”).
• Support pages handle cross-cutting entities (maps, safety, gear lists, leave-no-trace, local rules).

Each page should “own” an entity or a tightly bound set of entities; that ownership clarifies purpose and prevents keyword cannibalization.

3) Use a Knowledge Graph to Organize Relationships

A knowledge graph is a network of nodes (entities/pages) and edges (relationships). On a website, it shows:

• Hierarchical relationships: The “Rexburg Hiking Trails” pillar links down to each named trail page; each trail page links back up to the pillar.
• Associative relationships: Pages cross-link based on shared attributes (“more waterfall hikes,” “similar distance,” “same land manager”).
• External grounding: Use schema.org JSON-LD with stable @id URIs and sameAs links to authoritative sources (e.g., USFS, BLM) to anchor entities in the larger web graph.

Practically, your graph should be mirrored in navigation, breadcrumbs, internal links, and schema markup. That alignment makes both bots and humans feel oriented.

4) Step-by-Step Example: “Rexburg Hiking Trails”

Goal: Build a local hiking guide that a generative engine can trust and cite.

Step 1: Define the core entity and user intents

• Core entity/page: Rexburg Hiking Trails (Guide) — purpose: discovery and trip planning.
• Primary intents: “find a hike,” “compare difficulty,” “see maps,” “check seasonal conditions,” “learn rules and safety.”

Step 2: Inventory entities and attributes

• Trail entities (examples): R Mountain (Menan Butte), Cress Creek Nature Trail, Packsaddle Lake, Moody Creek Loop.
• Attribute entities: Difficulty (Easy/Moderate/Hard), Features (Waterfall, Viewpoint), Season (Spring, Summer, Fall), Hazards (ticks, heat, river crossings), Land managers (BLM, USFS).
• Support entities: Maps & GPX, Trailhead parking, Fees/Permits, Leave No Trace, Local weather patterns.

Step 3: Design the information architecture (IA)

• Pillar:/trails/ → Rexburg Hiking Trails (Guide)
  • Sections on the pillar:
    • “Top Picks” (editorial curation)
    • “By Difficulty” (Easy, Moderate, Hard)
    • “By Feature” (Waterfalls, Lakes, Views)
    • “Seasonal Guides” (Spring mud, Summer heat, Fall colors)
    • “Maps & Safety” (regional map, GPX, safety primers)
• Clusters (subpages):
  • /trails/r-mountain/ (entity: specific trail)
  • /trails/cress-creek/
  • /trails/packsaddle-lake/
  • Thematic lists: /trails/waterfalls/, /trails/easy/, /trails/family-friendly/
• Support pages:
  • /maps/ (downloadable GPX, embedded interactive map)
  • /safety/ (hydration, sun, wildlife, cell coverage)
  • /seasons/ (trail conditions and tips by month)
  • /rules/ (dogs, drones, fires, permits; link to land managers)

Step 4: Model the relationships (internal links + schema)

• On the pillar, list and link every trail entity with concise cards (distance, elevation, difficulty).
• On each trail page, link back to the pillar and out to sibling “similar trails” via shared attributes (e.g., “More easy hikes,” “More lake hikes”).
• Add breadcrumbs (Home → Trails → R Mountain).
• In JSON-LD, represent a TouristAttraction or Place for each trail with stable @id (your canonical URL), plus isPartOf (the trails guide), areaServed (“Rexburg, Idaho”), and sameAs (authoritative external IDs when available).

Step 5: Populate content with entity-first details

Each trail page should consistently cover: overview, distance, elevation, route description, trailhead coordinates, parking/fees, land manager, seasonality, hazards, facilities, and leave-no-trace notes. Use structured headings and a quick-glance fact box so both users and engines can extract facts.

Step 6: Reinforce topical authority

• Create guides that slice by attributes: “Beginner Hikes near Rexburg,” “Best Hikes for July.”
• Maintain update notes (e.g., “bridge out as of June 2025”). Freshness plus entity consistency signals reliability.

5) Common Mistakes to Avoid

• Keyword stuffing vs. entity modeling: Jamming “Rexburg hiking trails” into every paragraph won’t help. Instead, cover the right attributes and link the right related entities.
• Flat sites with no hierarchy: A pile of blog posts is not a topical model. Use pillars, clusters, and support pages.
• Orphan pages: Every subpage should have at least one parent and several lateral links based on shared attributes.
• Ambiguous naming and duplicate entities: Don’t split one trail across multiple near-duplicate pages (e.g., “R Mountain Hike” vs. “Menan Butte Trail”). Pick one canonical entity and redirect/merge.
• Inconsistent facts: Distance or rules that vary across pages erode trust. Keep a single source of truth and reuse it.
• Missing schema or unstable identifiers: Use JSON-LD with stable @id per entity. Changing URLs/IDs breaks the graph.
• Over-fragmentation: Don’t make pages so narrow they lack substance (e.g., a standalone page for “trail length definition”). Combine thin concepts into a richer page.

Key Takeaways

• Structure your site around entities, not just keywords.
• Use a pillar → cluster hierarchy; let attributes drive smart cross-links.
• Mirror your knowledge graph in navigation, breadcrumbs, internal links, and schema.
• Give each entity a stable URL and @id, and ground it with authoritative sameAs links.
• Write consistent, attribute-rich content to boost SEO discoverability and GEO citability.
• Avoid flat hierarchies, orphan pages, duplicated entities, and keyword stuffing.
• Keep facts consistent and pages fresh; topical coherence + freshness = trust.