How to Do On Page SEO Step by Step

How to do on page seo means improving one page so its content, HTML, links, speed, and crawl signals better match search intent and technical best practices. The most reliable method is a page-level workflow: audit the URL, fix content issues, fix technical issues, then verify the page again before scaling the process.

On-page SEO is easiest to apply when you stop thinking in vague ranking factors and start reviewing one URL from top to bottom. That approach helps beginners, content teams, and developers work from the same checklist.

This guide uses a single-page workflow. You will audit a live page, separate content checks from technical checks, make edits, and compare the page before and after.

When you need to automate those checks across many URLs, YepAPI's On-Page API is the programmatic version of the same process. You can also pair it with YepAPI's on-page content endpoint for page text analysis and YepAPI's Lighthouse endpoint for performance signals.

What is on-page SEO?#

On-page SEO is the practice of improving elements on a page that you control. Those elements include the title tag, meta description, H1, H2s, body copy, URL slug, internal links, image alt text, schema markup, and technical HTML signals.

Google explains that helpful content should satisfy a searcher's need and make the page easy to understand for people and search engines alike in its SEO starter guide. Page experience also matters because speed and stability affect usability, as Google documents in its Core Web Vitals overview.

On-page SEO is different from off page seo ranking factors. Off-page work earns signals from other sites, while on-page work improves the page itself.

Why on-page SEO matters#

On-page SEO helps search engines understand what a page is about. It also helps users decide whether the result deserves a click and whether the page answers the query once they land.

A page can miss rankings even when the topic is strong. The common reasons are mismatched search intent, weak structure, duplicate tags, thin internal linking, slow rendering, or missing technical hints like canonicals.

For developers and SEOs, on-page work is one of the fastest areas to improve because the fixes are usually under your control. Unlike link building, you do not need another site to act first.

how to do on page seo: the workflow#

Use this order every time you optimize a page:

1. Choose one URL and one primary query.
2. Confirm the search intent behind that query.
3. Capture the page's current on-page state.
4. Fix content elements first.
5. Fix technical on-page issues second.
6. Recheck the page after publishing edits.
7. Track similar issues across the rest of the site.

This sequence matters. If you rewrite copy before confirming search intent, or tune performance before fixing a misleading title tag, you can improve the wrong page.

Step 1: Choose one URL and one primary query#

Start with a specific page, not a whole site. A collection page, blog post, product page, or landing page all work as long as you know which query the page should rank for.

Pick one primary keyword and a small set of closely related supporting phrases. If you need that research first, YepAPI's Keyword API and keyword ideas endpoint let you pull terms, variants, and adjacent opportunities in code.

Your page cannot target every variation well. A single page usually performs better when it solves one intent clearly.

Step 2: Match search intent before editing anything#

Search intent is the job the query is trying to get done. Typical intents are informational, navigational, commercial, or transactional.

Before editing, ask four questions:

1. Does the current page type fit the query?
2. Does the title promise the same thing the query asks for?
3. Does the opening section answer the query quickly?
4. Do the headings cover the subtopics users expect?

For example, a page targeting "how to do on page seo for beginners" should teach a process. A page targeting a tool comparison should not open with a generic definition and no practical steps.

If you are unsure what Google is rewarding, YepAPI's Google SERP API is the fastest way to inspect result types and ranking patterns at scale. That is especially useful when content teams need to classify many pages by intent.

Step 3: Capture the page before you change it#

You need a baseline. Otherwise, you are guessing whether the edits helped.

Record these page-level signals before making changes:

For a quick page scan, YepAPI's On-Page API can pull many of these checks from a URL. For broader domain context, YepAPI's domain pages endpoint helps you inspect page inventory and spot similar templates.

If the page redirects, fix that first. Mixed redirect behavior can change how a page is crawled and consolidated, which is why it helps to understand 301 redirect vs 302 before optimizing the URL itself.

Step 4: Fix content optimization first#

Content issues usually have the largest impact because they determine whether the page answers the query well.

How to do on page seo for beginners#

Beginners should focus on the visible page elements in this order:

1. Title tag
2. H1
3. Intro paragraph
4. H2 structure
5. Body copy depth
6. Internal links
7. Images and alt text

That order keeps the work practical. It also avoids wasting time on minor tweaks before the page says the right thing.

Title tag and meta description#

The title tag should state the topic clearly and encourage the click. The meta description should summarize the page honestly, even though Google may rewrite it.

A weak title tag often fails in one of three ways: it hides the topic, overuses keywords, or promises something the page does not deliver. Keep it specific.

H1, H2s, and content structure#

Your H1 should describe the page's main subject. Your H2s should break the page into the subtopics users expect to see.

This is where many pages fail. They mention the primary keyword but never answer the actual follow-up questions users have after the click.

A simple check is to read only the H1 and H2s. If the page still makes sense as an outline, the structure is probably doing its job.

Internal links and external links#

Internal links help users and crawlers move between relevant pages. They also clarify which pages on your site support the current topic.

Use internal links where the reader naturally needs more detail. For technical fixes that affect URL handling and index signals, technical seo best practices is a useful companion. For authority signals outside the page, see how to check website domain authority.

External links should support factual claims or point to authoritative references. Schema markup, for example, follows the vocabulary defined by Schema.org.

Images and alt text#

Images should help explain the page, not just decorate it. Alt text should describe the image for someone who cannot see it.

Do not stuff keywords into alt text. MDN's reference for the HTML img element explains that the alt attribute is replacement text for the image, not a place to repeat your target phrase unnaturally.

Step 5: Fix technical on-page issues second#

Technical on-page work makes the content accessible, crawlable, and renderable. It does not replace good content, but it often determines whether that content is interpreted correctly.

Split your technical checks into five buckets:

1. Indexability
2. Canonicalization
3. Mobile rendering
4. Performance
5. Structured data

How to check page SEO#

When you check page SEO objectively, inspect the page as rendered HTML and as a URL in a crawl path. Review:

• Status code
• Canonical tag
• Meta robots
• Render-blocking resources
• Mobile viewport behavior
• Core Web Vitals issues
• Broken internal links
• Missing structured data

If the page returns the wrong status or points to another URL canonically, content edits on that page may not matter. Likewise, if the page sits behind redirect hops, solve those first. If you need a refresher on redirect behavior, what is 301 redirect covers the permanent case.

For repeatable technical checks, YepAPI's Lighthouse endpoint is useful for performance and rendering diagnostics, while YepAPI's On-Page API helps surface HTML-level SEO issues from a URL.

Core Web Vitals and mobile-friendly design#

Fast pages are easier to use. Stable pages are easier to trust. Mobile-friendly layouts are mandatory because most sites now earn a large share of traffic on small screens.

Check whether important content shifts during load, whether images reserve space, and whether fonts or scripts delay rendering. These are not separate from SEO because poor rendering can reduce usability and crawl clarity.

Canonical tags and crawlability#

A canonical tag tells search engines which URL is the preferred version when similar pages exist. It is a hint, not an order, so it still needs to align with internal linking, redirects, and page content.

Crawlability means bots can reach the page and its resources without unnecessary barriers. If CSS or JavaScript needed for rendering is blocked, the page can be understood incorrectly.

Step 6: Before-and-after example for one page#

The easiest way to learn this process is to see a compact example.

how to do on page seo examples#

Imagine a page targeting "how to set up payroll software" on a SaaS site.

Before

• Title tag: "Software Solutions for Growing Teams"
• H1: "Welcome"
• No mention of payroll setup in the intro
• H2s are generic product marketing headings
• URL slug is /products/item-4821
• No internal links from setup guides
• Images have filename-based alt text
• Canonical points to a broader category page

After

• Title tag names payroll software setup clearly
• H1 matches the page's real purpose
• Intro answers the setup question in plain language
• H2s cover steps, pricing, migration, and support
• URL slug is short and descriptive
• Internal links added from related implementation pages
• Alt text describes diagrams and screenshots accurately
• Canonical points to the page itself

This is a true on-page improvement because both relevance and crawl signals got better. The page now states its topic, matches intent, and removes technical ambiguity.

Step 7: Recheck the page after publishing edits#

Do not stop after making changes. Verification is the missing step in most on-page SEO guides.

Recheck the same fields you captured earlier:

1. Did the title tag and H1 change as intended?
2. Does the rendered HTML include the updated copy?
3. Is the canonical correct?
4. Are internal links live?
5. Did performance degrade after new assets or scripts?
6. Does the page still return the expected status code?

This before-and-after pass is where YepAPI's On-Page API becomes especially useful. You can run the same URL before a deploy and after a deploy, compare outputs, and flag changes that need review.

How to do SEO for a coded website#

A coded website changes the workflow only slightly. The principles stay the same, but the implementation path is different from WordPress.

On a custom-coded site, pay special attention to templates, components, and deployment logic. One bug in a shared layout can duplicate title tags, remove canonicals, flatten heading structure, or inject the wrong meta robots tag across hundreds of pages.

For coded websites, use this checklist:

1. Check the template that prints the title tag and meta description.
2. Confirm each route outputs one meaningful H1.
3. Review how canonicals are generated.
4. Verify server-side rendering or hydration does not hide key content.
5. Test mobile layout and performance on template variants.
6. Audit internal linking components such as breadcrumbs, related pages, and nav patterns.

This is where doing on-page SEO in code matters most. Instead of fixing one page manually, developers can update the template and use YepAPI's On-Page API across a URL list to verify the output at scale.

How to set up SEO on WordPress#

WordPress makes many edits easier because page titles, slugs, headings, and media fields are exposed in the CMS. The risk is that plugins and theme settings can create technical issues quietly.

When setting up SEO on WordPress, review:

• Permalink structure
• Page and post title templates
• Category and tag archive indexability
• Duplicate schema from multiple plugins
• Image compression and lazy loading
• Mobile performance after theme or builder changes

The workflow is still the same: match intent, optimize content, fix technical issues, then recheck the page.

Running on-page SEO at scale with an API#

Manual review works for a few URLs. It breaks down when you manage hundreds or thousands.

YepAPI's On-Page API is the scalable answer because it can audit a page URL in code and return structured SEO checks. YepAPI's on-page content endpoint helps with visible content inspection, and YepAPI's Lighthouse endpoint supports automated performance review.

A practical batch workflow looks like this:

1. Export a list of URLs from your CMS or crawler.
2. Send each URL to YepAPI's On-Page API.
3. Group issues by template, content type, or severity.
4. Re-run the same URLs after fixes.
5. Store the before-and-after results for QA.

That process is more reliable than a spreadsheet-only checklist because the checks are repeatable. It is also CMS-agnostic, which matters if your site includes WordPress pages, a React app, and custom server-rendered routes.

A practical checklist you can reuse#

Use this page-level checklist on every important URL:

1. Confirm one primary query and one clear intent.
2. Rewrite the title tag if it hides the topic.
3. Align the H1 and intro with the query.
4. Rebuild H2s around real subtopics.
5. Improve body copy where the page is thin or vague.
6. Add internal links from closely related pages.
7. Check image alt text for clarity, not keyword stuffing.
8. Fix URL, canonical, and indexability issues.
9. Test mobile rendering and Core Web Vitals.
10. Re-audit the page after publishing changes.

That sequence is what most generic on-page SEO lists miss. The goal is not to tick isolated boxes. The goal is to improve one page in a way you can verify and repeat.

CTA: run the workflow in code#

If you want to do this across more than a handful of URLs, use YepAPI's On-Page API. It gives you a repeatable way to audit pages, compare before-and-after output, and support technical SEO QA with $5 free credit and no card.

FAQ#

What to do in off-page SEO?#

Off-page SEO focuses on signals outside the page itself. That usually means earning backlinks, building brand mentions, improving citations where relevant, and promoting pages that deserve links. On-page SEO makes the page clear and crawlable first; off-page SEO helps search engines trust it more after that foundation is in place.

How to do SEO for a coded website?#

Do SEO for a coded website by checking templates, rendered HTML, canonicals, headings, internal linking components, and mobile performance across real URLs. The biggest risk is a template bug that affects many pages at once. Audit one page manually first, then recheck the same rules across the full URL set in code.

How to check page SEO?#

Check page SEO by reviewing the title tag, meta description, H1, H2s, URL slug, internal links, image alt text, schema, canonical tag, status code, and mobile performance. Capture those signals before edits and after edits. That before-and-after comparison is what tells you whether the page actually improved.

How to set up SEO on WordPress?#

Set up SEO on WordPress by confirming permalinks, editing page titles and meta descriptions, using clear headings, compressing images, and checking canonicals, schema, and index settings. WordPress makes content edits easy, but themes and plugins can create duplicate markup or slow pages, so always re-audit the final page output.