Author: admin

---
name: map-your-money-tree
description: Draw any website as a money tree — trunk (domain), limbs (offer groups), branches (money pages and definitive hubs), leaves (posts that link up to them) — measured from the site's real internal links, then diagnose the six defects a sitemap hides and output a dated publishing plan. Use when someone asks "which of my pages actually make money", "why isn't my content converting", "map my site", "audit my internal links", or when a monthly MAA needs a structural section.
author: Dennis Yu — BlitzMetrics / Local Service Spotlight
license: Apache-2.0
version: 1.0 (2026-08-15)
references:
  - https://blitzmetrics.com/money-tree/
  - https://blitzmetrics.com/seo-tree/
  - https://blitzmetrics.com/money-pages-vs-blog-posts/
  - https://blitzmetrics.com/maa/
  - https://blitzmetrics.com/9-triangles-framework-scalable-home-service-businesses/
  - https://localservicespotlight.com/quick-audit/
---

# Map Your Money Tree

**Use this when** you need to know which pages on a site actually earn, and which of the
content already published is feeding them. Not "how much traffic does this page get" —
*what is connected to what, and in which direction.*

This is the structural half of [MAA](https://blitzmetrics.com/maa/). The leaf counts are
the Metrics. The bare and split branches are the Analysis. The publishing list at the end
is the Action. Redraw it monthly and the delta is the report.

## The one idea

**A leaf counts only when it actually links.**

Not when it is topically related. Not when it sits in the right category. Not when someone
meant to link it. The link is the measurement; everything else is a plan. Every number this
skill produces must be reproducible by re-running the crawl.

---

## The five layers

| Layer | What it is | How you know |
|---|---|---|
| **Root** | Off-site proof of the entity: Knowledge Panel, Wikidata, LinkedIn, YouTube, podcast appearances, press, review profiles. | It is not on the domain and you cannot edit it directly. |
| **Trunk** | The domain and its home page — the entity home. | It is the URL you would put on a business card. |
| **Limb** | A group of branches sharing an audience or a job — the offers, the method, a vertical. | It is how the site's own services page already groups things. |
| **Branch** | A money page, or a definitive article that owns a concept. | Someone converts on it, or it is the one canonical page for a topic. |
| **Leaf** | A post that links **up** to a branch. | It is dated, it flows through a feed, and its body contains a link to its branch. |

Roots and trunk are **Why**. Limbs and method branches are **How**. Money branches are
**What**. Leaves are **Proof**. A stranger — or a language model — should be able to read
all four off one page.

---

## Inputs

- The domain.
- Read access to every published URL and its **rendered** body (not raw — page-builder and
  shortcode markup must be expanded so the links inside are visible).
- The site's own services page and main navigation, for the branch list and its grouping.
- Optional: the previous run's tree, for the delta.

---

## Procedure

### 1. Inventory every published URL
Posts and pages both, with id, URL, title, publish date, and rendered body.

On WordPress:
```
GET /wp-json/wp/v2/posts?per_page=100&page=N&status=publish&_fields=id,link,title,content,date
GET /wp-json/wp/v2/pages?per_page=100&page=N&status=publish&_fields=id,link,title,content,date
```
Page until the `X-WP-TotalPages` header runs out. On any other stack, use a crawler that
returns rendered HTML. De-duplicate by (type, id) — retried requests double-count silently.

### 2. Extract internal links from every body
Match `href` values on the site's own host. Normalise: drop the query string and fragment,
force a trailing slash, lower-case the host. **Make the set unique per source page** — a
post linking to the same branch five times is one leaf, because the first link is the one
that carries the value.

```js
const RX = /href="https?:\/\/(?:www\.)?example\.com(\/[^"#?]*)/g;
const outs = [...new Set([...html.matchAll(RX)].map(m => m[1].replace(/\/+$/,'') + '/'))];
```

For a personal brand site, also match the company domains — its money pages usually live
on another host, and they still count as branches.

### 3. Build the inbound index
Invert the map: for every URL, the list of posts and the list of pages that link to it.
Count them **separately**. Theme headers and footers are pages linking to pages; only body
links from posts are leaves.

### 4. Name the branches from the site, not from memory
Take the money pages off the services page and the main navigation, in the grouping those
pages already use. Add the definitive articles — the pages that own a concept. Do not
invent a tidier taxonomy than the one the site presents to a visitor: if your tree
disagrees with the navigation, the tree has just found its first defect.

### 5. Resolve redirects and duplicates before counting
Request each branch URL and follow the chain. Merge redirected URLs into one branch and
**report the merge** rather than hiding it. Two live 200s for one offer is a split branch,
not two branches. This is the step everyone skips and where most findings are.

### 6. Draw it to scale
Branch thickness and foliage density from the leaf count on a **square-root** scale, so a
300-leaf branch does not visually annihilate a 30-leaf one. Bare branches drawn bare.
Nothing placed by hand — if the drawing is prettier than the site, the drawing is lying.

### 7. Publish it on the site it maps
As a live page with every node a real link — never a screenshot. Ship three synchronised
forms on the same URL: the diagram (inline SVG), the identical structure as a **visible**
text outline, and `ItemList` JSON-LD naming each branch, its role, its content type and its
inbound count. The picture is for humans; the other two are for agents.

---

## The six defects — and where each one routes

Diagnosis is worthless without a destination. This is a scan that names the department.

| # | Defect | What it looks like | What it costs | Routes to |
|---|---|---|---|---|
| 1 | **Bare branch** | A live money page with zero posts linking to it | Nothing on the site has ever pointed a visitor at the thing you sell | Content — one customer story per bare offer |
| 2 | **Split branch** | Two live URLs for one offer (usually a page and a post) | Internal links divide; neither ranks as well as one would | Plumbing — pick one, 301 the other, consolidate |
| 3 | **Redirect tax** | Many internal links pointing at a URL that 301s | Every link takes the slow road; often includes the main nav | Plumbing — rewrite links to the destination |
| 4 | **Broken target** | Internal links pointing at a 404 | Invisible in analytics, because nobody clicks a link they cannot see | Plumbing — restore or repoint |
| 5 | **Inverted tree** | Leaf counts fall as price rises | The cheapest offer carries the most proof; the most expensive carries none | Strategy — decide what you are actually selling |
| 6 | **Canopy with no branches** | Hundreds of posts linking to each other and almost nothing structural | Looks enormously productive, converts nothing | Personal brand — wire the proof to an offer |

Also check the roots. A tree with no off-site proof — no Knowledge Panel, no consistent
`sameAs`, no third-party corroboration — is standing in loose soil no matter how good the
canopy looks. That routes to entity/authority work.

---

## The QA gate — nine checks, all must pass

A wrong tree is worse than no tree, because people act on it.

1. **Every node resolves.** Status recorded for each branch; no 404s; every 301 shown as a redirect rather than silently followed.
2. **Counts are reproducible.** Re-run the crawl; identical numbers. Drift means the extractor is matching something other than links.
3. **Counts are unique per source.** One post linking three times counts once.
4. **Navigation excluded.** Only body links from posts are leaves.
5. **No branch invented.** Every branch appears in the site's own navigation, services page, or definitive-article set.
6. **No money page missing.** Cross-check against the services page and main menu. A money page absent from the tree is the worst error — an invisible bare branch reads as a branch that does not exist.
7. **Duplicates consolidated.** Split URLs appear as one branch, flagged, with both URLs named.
8. **Text outline matches the diagram.** Same nodes, counts and order — that is what agents and screen readers read.
9. **Date and method stated.** A tree without a crawl date is a claim, not a measurement.

---

## Output

1. **The diagram** — inline SVG, every node an anchor, light/dark, no runtime JS.
2. **The text outline** — visible, nested, live links, counts, health flags.
3. **The schema** — `ItemList` JSON-LD, one entry per branch.
4. **The findings** — the defects above, each with the specific URLs and counts.
5. **The action list** — dated, ordered by cost-to-fix, one line per bare branch.
6. **The delta** — versus the previous run. Any branch still bare after a redraw is a branch nobody has decided to sell.

## Definition of done

- Every branch on the services page and main nav appears in the tree.
- Every count is reproducible and every URL resolves or is flagged.
- The page carries diagram + outline + schema on one URL.
- Every defect names a destination, not just a problem.
- The next publishing action is unambiguous to someone who did not run the audit.

## Cadence

Monthly on an active site. The value is in the delta, not the snapshot. A metric you look
at once is a screenshot.

---

*Method: <https://blitzmetrics.com/money-tree/> · Framework: <https://blitzmetrics.com/seo-tree/> ·
Page-versus-post rule: <https://blitzmetrics.com/money-pages-vs-blog-posts/> ·
Want it run for you: <https://localservicespotlight.com/quick-audit/>*