Local Marketing Strategy for Small Businesses in Utah

Utah office: Pleasant Grove, UT — serving businesses across the U.S.

Local marketing helps a business show up when people search for services online. A good strategy has two parts:

On-page SEO: what you do on your website (your pages, titles, speed, and content).
Off-page SEO: what happens off your website (your Google Business Profile, directory listings, and links from other sites).

Below is a simple approach you can use for your small business in Utah.

On-Page SEO

On-page SEO is about making sure your website is easy to understand, fast, and easy to use on a phone.

1) Start with what people type into Google

Keyword research is one of the most important parts of on-page SEO.

It’s how you line up each page of your website with what real people are actually searching for. If the page doesn’t match the words customers use, it’s much harder for it to rank — even if the page looks great.

Pick one primary topic per page.

Home page: what you do + where you do it.
Service pages: one core service per page.
Location pages (if you have them): one location per page.

When you choose keywords, focus on what customers actually type, and make it local:

Service + city (example: “roof repair Provo”)
Service + county (example: “website design Utah County”)
Service + near me (your Google Business Profile helps a lot here)

Easy option: Google Keyword Planner (inside Google Ads)

Google Ads has a keyword tool that’s hard to beat for local keyword discovery:

In Google Ads, go to Tools → Planning → Keyword Planner.
Use Discover new keywords.
Set the location to your service area (for example: Utah County, Salt Lake County, or specific cities).
Review keyword ideas and the search volume for that exact area.

This is one of the best ways to discover what people are searching for in your local market so you can build pages that match demand.

Other ways to get keyword ideas

Google Autocomplete: start typing a service + city and note the suggestions.
Paid tools (optional): Semrush and Ahrefs.

Google Search Console (see what you already show up for)

If your site is verified in Google Search Console, it’s one of the best ways to find keywords you’re already showing up for.

Go to Search Console → Performance → Search results.
Look at Queries (the exact searches people used) and Pages (which page showed).
Filter by country (United States) and, if helpful, compare mobile vs. desktop.
Find opportunities like:
- Searches where you’re showing up a lot, but you’re sitting around positions 8–20 (almost page 1).
- Searches where people see your result but don’t click it much (low CTR).
- A page that shows up for a bunch of related searches but doesn’t fully answer them.

Then expand the page that’s already ranking:

Add missing sections that answer those queries directly.
Add local proof (photos, process, service area details).
Improve headings so the page is easier to scan.
Add a short FAQ for common questions.

This “upgrade what already works” approach is a faster way to improve results than creating a brand new page from scratch.

Make the page clearly local

Once you pick a keyword theme for a page, make the content local in natural ways:

Mention the cities/counties you actually serve (only where it fits).
Add local proof: photos, projects, and before/after examples.
Answer local questions (pricing ranges, timelines, permits, seasons, etc. — whatever fits your business).

2) Use clear page titles, headings, and URLs

These are some of the strongest “what is this page about?” signals.

Title tag: include the service + your city/state (or a very specific niche topic) when it makes sense.
- If you leave the location out, you’re competing nationally.
- Adding the city/county/state helps Google (and customers) connect the page to your local area.
- Going over ~60 characters is fine. That number is about what fits on screen, not a rule.
- The title tag and meta description are what people see in search results, so write them for humans.
H1: should match the main promise of the page.
H2/H3 headings: organize the page into scannable sections.
URL slug: short and readable (avoid stuffing).

3) Write like a real person

The best-performing local pages do three things:

Answer common questions quickly.
Show real proof (photos, examples, process).
Make it easy to contact you.

Avoid thin content (and consolidate when pages overlap)

One strong, helpful page beats several thin pages that are basically saying the same thing.

If multiple pages (or old blog posts) cover the same topic, combine them into one deeper page:

Merge the best parts into a single page that fully answers the search intent.
Keep one URL as the “main” page.
Redirect the old URLs to the main page so you don’t lose existing signals.

Google favors pages that are clear, helpful, and thorough. Aim to make each page the best answer someone could find.

Reference: Google’s SEO Starter Guide is a solid baseline for what Google expects from a well-built site: https://developers.google.com/search/docs/fundamentals/seo-starter-guide

4) Mobile friendliness (Google cares)

Most local searches happen on a phone. If a site is hard to use on mobile, people bounce — and that hurts performance over time.

Google also evaluates your website from a mobile perspective. If the mobile version is slow, hard to use, or broken, it’s common to see rankings and conversions drop.

A mobile-friendly website has:

Responsive layout (content stacks and resizes cleanly)
Readable text without zooming
Tap-friendly buttons and links
Navigation that works with one thumb
No popups that block the main content on mobile

5) Use PageSpeed Insights to find the biggest wins

Google’s free tool PageSpeed Insights is one of the fastest ways to spot problems.

What to look at:

Mobile score and “Core Web Vitals”: Google’s basic speed/usability checks (mobile matters most).
Largest Contentful Paint (LCP): how fast the main content shows up (for example, a hero image).
Interaction to Next Paint (INP): how “snappy” the page feels when someone taps/clicks.
Cumulative Layout Shift (CLS): whether the page jumps around while loading.

Common fixes that matter most:

Compress images and serve modern formats (AVIF/WebP when possible)
Lazy-load below-the-fold images
Limit scripts (especially third-party scripts)
Cache static files (a CDN helps)

6) Images: keep them small and fast

Images are one of the most common reasons a mobile page is slow.

Lazy-load images lower on the page

Add loading="lazy" to images that aren’t part of the first screen.
Set image dimensions (width/height or an aspect ratio) so the page doesn’t jump while images load.

Compress before you upload

Quick option: compress JPG/PNG files with https://tinyjpg.com/ (or TinyPNG).
If you upload lots of images, it helps to have a simple process you reuse each time. If you want, an AI tool can help you create a simple helper to resize and compress them.

Example: batch resize/compress on Mac or Linux (ImageMagick)

This is a simplified version of the ImageMagick resize script idea: resize images to a max width, then reduce quality until each file is under a target size. It’s a good starting point you can customize.

#!/usr/bin/env bash

set -euo pipefail

folder_path="${1:-.}"
target_size=130000 # bytes (~130 KB)
max_width=1200

command -v magick >/dev/null 2>&1 || {
  echo "ImageMagick not found. Install it first (macOS: brew install imagemagick)." >&2
  exit 1
}

cd "$folder_path" || exit 1
mkdir -p Resized Originals
shopt -s nullglob

for input_image in *.jpg *.jpeg *.JPG *.JPEG *.png *.webp *.heic *.HEIC; do
  base="${input_image%.*}"
  output="Resized/${base}.jpg"

  # Linux vs macOS stat
  if stat --version >/dev/null 2>&1; then
    size=$(stat -c %s "$input_image")
  else
    size=$(stat -f %z "$input_image")
  fi

  quality=85
  while :; do
    magick "$input_image" -resize "${max_width}x" -quality "$quality" -sampling-factor 4:2:0 -strip "$output"

    if stat --version >/dev/null 2>&1; then
      new_size=$(stat -c %s "$output")
    else
      new_size=$(stat -f %z "$output")
    fi

    [ "$new_size" -le "$target_size" ] && break

    rm -f "$output"
    quality=$((quality - 10))
    [ "$quality" -le 30 ] && {
      magick "$input_image" -resize "${max_width}x" -quality 30 -sampling-factor 4:2:0 -strip "$output"
      break
    }
  done

  mv "$input_image" "Originals/"
done

To install ImageMagick on macOS: brew install imagemagick.

Image basics that affect SEO (still worth doing)

Use descriptive file names when possible.
Add helpful alt text (describe the image; don’t spam keywords).
Keep images small enough to load quickly on mobile.

7) Third-party scripts: load fewer, load later

Third-party scripts can slow a site down on mobile (analytics, chat widgets, heatmaps, embedded maps, schedulers, etc.).

When possible, delay loading scripts until someone interacts with the page (or after a short timeout). This helps mobile speed.

<script>
(function () {
  function loadTrackingScripts() {
    if (window.trackingLoaded) return;
    window.trackingLoaded = true;

    // Example: insert your tracking script(s) here.
    // Create <script async src="..."></script> and append to <head>.
  }

  setTimeout(loadTrackingScripts, 4000);
  document.addEventListener('scroll', loadTrackingScripts, { once: true });
  document.addEventListener('mousemove', loadTrackingScripts, { once: true });
  document.addEventListener('touchstart', loadTrackingScripts, { once: true });
})();
</script>

Tip: This same pattern can be used for analytics, chat widgets, schedulers, and embedded map scripts.

8) Structured data (optional)

For local businesses, a little structured data can help search engines understand your business details.

Common schema types:

Local business / professional service
Service

Off-Page SEO

Off-page SEO is about showing Google that your business is real and trusted.

Google Business Profile
Citations (directory listings)
Local links (backlinks)

1) Google Business Profile (GBP)

Your Google Business Profile is the first thing customers see.

Focus on:

Primary category: choose the closest match to your main service.
Services: fill out the service list (don’t leave it empty).
Description: clear, plain language about what you do and where.
Photos: real photos build trust (office, team, work, before/after).
Q&A: add a few common questions (and answer them).
Posts: occasional updates can help engagement.
Website link: send people to the most relevant page (for example, a service page).

2) Directory listings (citations)

A “citation” is just your business listed on other sites (like directories).

The most important rule is consistency:

Name
Address
Phone number

Keep these consistent across platforms.

3) Links from other sites

Links are still one of the strongest trust signals. For local results, quality matters much more than volume.

Ideas that work for Utah small businesses:

Chamber of Commerce listings
Local sponsorships (events, teams, nonprofits)
Vendor/partner pages (suppliers, associations)
Local PR (announcing something genuinely newsworthy)
Helpful resources people want to reference (guides, checklists, calculators)

Avoid “shortcut” link tactics. They can create short-term gains but long-term problems.

4) What affects local rankings

Local visibility comes down to three things:

Match (relevance): do your pages and Google Business Profile match what someone searched?
Trust (prominence): do links and mentions show that you’re a legit business?
Distance (proximity): how close is the searcher to your location?

You can’t control distance, but you can improve match and trust.

Next step

If you want help applying this strategy (website + local marketing), visit Clear Presence in Utah or reach out on the contact page .