Your PageSpeed Score Isn’t the Whole Story

PageSpeed Score isn’t the whole story, with a glowing cyan and magenta glass ring.

You ran your site through PageSpeed Insights, saw a red number (or a suspiciously perfect green one), and felt either doomed or done. Neither reaction is quite right.

That score is useful. It is also a gym report card, not a full physical. Google currently treats Core Web Vitals—Largest Contentful Paint, Interaction to Next Paint, and Cumulative Layout Shift—as the main field metrics for loading, responsiveness, and visual stability. They matter for how your site feels. They are not an instant-ranking magic wand, and a single Lighthouse run is not the whole verdict.

Keep Reading

Funniest Prank Links on the Internet

Prank links illustration with an endless loading spinner, captcha checkbox, and empty search results.

Most websites try to get you somewhere. These take the scenic route. Forever.

A loading screen that never finishes. A captcha that refuses to acknowledge your humanity. A password form with exactly zero correct answers. Some of the funniest prank links work because they look like things you already put up with online—just a little less cooperative.

That’s the idea behind the Forever Loading Website, our collection of browser-based pranks. You don’t need to install anything or borrow someone’s phone. Pick a prank, copy its link, and send it to a friend who appreciates a little mischief.

Here’s what each one does and how to use it.

Keep Reading

How to Hire a Bettendorf Web Designer Without Rolling the Dice

Hire the right web designer in Bettendorf and the Quad Cities

You’ve decided your business needs a new website. Maybe the current one was built by your nephew in a weekend, or maybe it looks fine on a laptop and turns into a sliding puzzle on a phone. Either way, you typed “Bettendorf web designer” into a search bar and got a wall of options that all promise “stunning, results-driven websites.” Helpful.

This guide is the part those pages skip: what to actually look for in a Bettendorf web designer, the questions that separate the pros from the template-swappers, and how to decide between a local designer, a big agency, or doing it yourself. Then, yes, a little about how Photricity works, because I’d be a strange web designer if I didn’t mention it.

Think of It Like Building a House

Hiring a web designer is a lot like building a house. You can buy a prefab model off the lot, hire a big construction firm with a sales team and a project coordinator, or work directly with a builder who draws the plans, pours the foundation, and answers the phone when you have a question about the windows.

None of these is automatically wrong. But the blueprint matters more than the paint color, and a website’s foundation (its code, its structure, its hosting) decides whether it stands up for years or starts sagging the moment you add a room. Keep that picture in mind; we’ll come back to it.

What to Look for in a Bettendorf Web Designer

A good portfolio is the start, not the finish. Pretty screenshots tell you someone has taste. They don’t tell you whether the site behind them is fast, findable, or easy to live in. Here’s what to check:

Keep Reading

Event Horizon: A Plain-English GA4 Guide to Google Analytics 4

Your website is talking. Every click, scroll, form submission, and “nope, wrong page” exit is a little signal about what people want from you. Google Analytics 4 is how you listen. The trouble is that the first time you open it, it can feel less like listening and more like being handed the cockpit manual for a jet you didn’t know you owned.

This GA4 guide is the plain-English version. No hype, no “ten secret reports,” just the handful of concepts that make everything else click. Once you understand how Google Analytics 4 thinks, the menus stop being scary and start being useful. (If you’ve read our older post on gaining insight into your website traffic, consider this the modern, deeper sequel.)

Think of Your Website as a Restaurant

Here’s the analogy we’ll lean on for the rest of this post. Picture your website as a restaurant, and Google Analytics as the very attentive host with a notepad.

  • Users are the guests who walk through the door.
  • Sessions are individual visits. The same guest can come in for lunch on Tuesday and dinner on Friday: one user, two sessions.
  • Events are everything that happens at the table: sitting down, opening the menu, ordering an appetizer, asking for the check.
  • Key events are the moments that actually pay the rent, like ordering the chef’s tasting menu or booking the back room for a party.
  • Acquisition channels are how the guests heard about you: a food blog, a friend, a sign out front, or just walking by.

Keep that picture in mind. Almost every confusing GA4 screen is just the host’s notepad, sorted a different way.

How Google Analytics 4 Thinks: Everything Is an Event

The single biggest idea in GA4 is the event-based data model. Older analytics tools were built around pageviews and sessions, with other interactions bolted on. GA4 flips that around: everything is an event. A page loading is an event (page_view). A visit starting is an event (session_start). Someone scrolling far down the page, clicking a link to another site, or downloading a PDF are all events too.

Each event can carry parameters, which are extra details that describe it, such as which page was viewed or which file was downloaded. Think of the event as “ordered a drink” and the parameters as “iced tea, no lemon, table six.”

You don’t have to code most of this yourself. GA4 collects a set of events automatically, and a feature called enhanced measurement can track common interactions like scrolls, outbound clicks, site search, and file downloads with a simple toggle in your web data stream settings. Custom events are there for everything else.

Accounts, Properties, and Data Streams

GA4 organizes things in three layers:

  • Account: the top-level container, usually one per business.
  • Property: where your reports live and your settings are configured. Most small businesses need one property per brand or website.
  • Data stream: a source of data flowing into the property, such as your website (a web stream) or an iOS or Android app. Each web stream has a Measurement ID that starts with G-, which is what you or your developer paste into your site’s tag or plugin settings.

In restaurant terms: the account is the company, the property is the restaurant, and the data streams are the dining room and the takeout window, both reporting to the same host.

Key Events: Decide What Success Looks Like

Not every event matters equally. A key event is any event you mark as especially important to your business, like a contact form submission, a quote request, a purchase, or a newsletter signup. Any event you collect can be marked as a key event, and once it is, GA4 shows you which channels, pages, and campaigns lead people to do it.

You may still see the word “conversion” around GA4, and that’s not a typo. Google now uses key events for the important actions you analyze in Analytics, and reserves conversions for key events you use to measure and optimize Google Ads campaigns. If you don’t run ads, key events are the ones you care about. Either way, they’re the backbone of designing a website for higher conversion rates, because you can’t improve what you never defined.

If your site records a form submission with a custom event, it might look something like this:

Snippet: a custom event with gtag.js

// Fire after a quote form submits successfully
gtag('event', 'generate_lead', {
  form_name: 'quote_request',
  page_location: window.location.href
});

generate_lead is one of Google’s recommended event names, which means GA4 already understands what it represents. Once that event shows up in your property, mark it as a key event in Admin and it’ll start appearing in your key event metrics. Pro tip: fire it on the success state, not the button click, or you’ll count every frustrated person who hit “Submit” with an empty email field.

Users, Sessions, and Engagement Rate vs. Bounce Rate

GA4 counts users (the guests) and sessions (the visits), but the metric that tells you the most about quality is engagement.

An engaged session is a visit that meets at least one of these conditions:

  • It lasts longer than 10 seconds.
  • It includes a key event.
  • It includes two or more page or screen views.

Engagement rate is the percentage of sessions that were engaged. Bounce rate is simply the opposite: the percentage of sessions that were not engaged. So if your engagement rate is 62%, your bounce rate is 38%. Same coin, two sides.

That’s a much fairer definition than the old “left after one page” bounce. A visitor who lands on your blog post, reads the whole thing for four minutes, and leaves satisfied is engaged, not bounced. In restaurant terms: someone who orders, eats, and tips well didn’t “bounce” just because they didn’t also visit the bar.

One quirk: engagement rate and bounce rate aren’t shown in most default reports. You can add them by customizing a detail report (such as Pages and screens) if you have Editor or Administrator access, or pull them into an Exploration.

Where Your Visitors Come From: Channels and UTM Tags

GA4’s acquisition reports sort traffic into default channel groups like Organic Search, Direct, Referral, Organic Social, Email, and Paid Search. Each visit also gets a source (where it came from, like google or newsletter) and a medium (what kind of traffic it is, like organic or email).

You’ll see two flavors of acquisition report. User acquisition tells you how people found you for the very first time. Traffic acquisition tells you where each session came from, including returning visitors. Both are useful; they just answer different questions.

GA4 is pretty good at guessing, but for links you control, like emails, social posts, QR codes on a flyer, or a partner’s website, don’t make it guess. Add UTM parameters to the URL so the visit is labeled exactly the way you want:

Snippet: a UTM-tagged URL

https://example.com/spring-menu/?utm_source=newsletter&utm_medium=email&utm_campaign=spring_menu

The three you’ll use most are utm_source, utm_medium, and utm_campaign. Pick a naming convention (lowercase, underscores, no spaces) and stick to it, because GA4 treats Email and email as two different things. Use UTMs only on links pointing to your site from elsewhere; tagging your own internal links will overwrite the real source of the visit. Clean, readable URLs help here too, so it’s worth knowing the basics of building SEO-friendly URLs.

Reports vs. Explorations

GA4 gives you two main ways to look at data.

Reports are the ready-made dashboards: acquisition, engagement, pages and screens, events, and so on. They’re fast, easy to share, and perfect for regular check-ins. Think of them as the restaurant’s nightly summary: covers served, top dishes, busiest hour.

Explorations (found in the Explore section) are your workshop. You drag in dimensions and metrics, build free-form tables, funnels, and path analyses, and answer questions the standard reports don’t cover, like “What did people who requested a quote look at before they did it?” Explorations are where analysis happens; reports are where monitoring happens.

One thing to know up front: Explorations are limited by your property’s data retention setting, which controls how long user-level and event-level data is kept. Standard reports aren’t affected, but if you want to explore further back, check that setting in Admin early and set it to the longest option available to you. It isn’t retroactive.

Explorations are also a natural partner to experiments. If you’re running A/B testing for data-driven improvements, GA4 is where you check whether the winning variation actually produced more key events, not just more clicks.

Connect Search Console for the Other Half of SEO

GA4 tells you what visitors do after they arrive. Google Search Console tells you what happened before: which search queries showed your pages, how often you appeared, and how often people clicked. Linking the two in GA4’s Admin area (under product links) lets you see Search Console data inside Analytics, so you can connect a search query to the landing page and the engagement that followed.

If you haven’t set up Search Console yet, start with our guide on how to use Google Search Console. Pair the two and you’ll know which keyword research bets are paying off and which pages rank well but fail to hold attention once people land.

Consent and Privacy Basics

Analytics runs on visitor data, so privacy isn’t optional. Depending on where your visitors live, you may need to ask for consent before setting analytics cookies. GA4 supports consent mode, which lets your consent banner tell Google tags whether a visitor has agreed to analytics and advertising storage, and adjusts how tags behave based on that choice.

A few evergreen basics:

  • Use a consent banner or consent management platform that actually integrates with consent mode, rather than one that just looks the part.
  • Never send personally identifiable information, like names, email addresses, or phone numbers, to GA4 in event parameters or URLs. Google’s policies prohibit it.
  • Mention analytics in your privacy policy, in plain language.
  • Expect some gaps. When visitors decline cookies, your numbers will be lower than reality. That’s the cost of respecting people, and it’s worth it.

This isn’t legal advice, and the rules vary by region. If your business handles a lot of personal data, it’s worth a conversation with someone who does this for a living.

Filter Out Yourself (and Your Team)

If you check your own site twenty times a day, congratulations: you’re your own biggest fan, and you’re also skewing your data. GA4 lets you define internal traffic by IP address in your web data stream’s tag settings, then exclude it with a data filter in Admin.

Data filters have three states: Testing, Active, and Inactive. Start in Testing, which labels matching traffic without removing it, and confirm in an Exploration that the right visits are being caught. Only then switch it to Active. That step matters, because an active exclude filter is permanent: the data it removes is never processed and can’t be recovered.

Internal traffic is the friendly kind of noise. The unfriendly kind is bots, and that’s a whole topic of its own. If you’ve ever seen a mysterious spike of zero-second visits from a city you’ve never done business in, read how to spot and filter bot traffic in GA4.

Use Annotations to Remember Why Things Changed

Six months from now, you will look at a traffic jump and have absolutely no idea what caused it. Annotations fix that. In reports with line graphs, you can add a short note tied to a date or date range, like “Launched new homepage,” “Started email campaign,” or “Fixed broken contact form.” Annotations appear across all line-graph reports, so everyone with access gets the context.

Make it a habit: anytime you redesign a page, improve page load times, or launch a campaign, drop an annotation. Your future self will be grateful, and slightly smug.

Common GA4 Pitfalls to Avoid

  • Installing the tag twice. A theme setting and a plugin and Google Tag Manager all adding GA4 means double-counted pageviews and suspiciously perfect engagement. Pick one method.
  • Never marking key events. Without them, you have traffic data but no idea whether that traffic does anything.
  • Treating every metric as a goal. More sessions isn’t automatically better. A hundred engaged visitors who request quotes beat a thousand who leave in three seconds.
  • Messy UTM naming. Facebook, facebook, and fb become three separate sources. Write your conventions down.
  • Leaving data retention at the default. If you’ll want year-over-year Explorations, change it now. It doesn’t apply backward.
  • Activating filters without testing. Permanent means permanent.
  • Checking numbers too soon. Standard reports can take some time to process, so use the Realtime report for “is my tag working?” and the standard reports for actual decisions.
  • Expecting perfect accuracy. Ad blockers, declined consent, and privacy features mean GA4 is a strong directional signal, not a census. Look at trends, not single digits.

How to Use Google Analytics 4 Without Drowning in It

If you remember nothing else from this GA4 guide, remember this: decide what success means (key events), label where people come from (channels and UTMs), keep your data clean (internal traffic and bot filtering), and write down what you changed (annotations). Then check in regularly, ask one question at a time, and let Explorations do the heavy lifting when the standard reports run out of answers.

Your restaurant’s host is taking great notes. You just have to read the notepad.

And if you’re planning a new website, it’s much easier to build measurement in from day one than to retrofit it later. When we build a site, key events, clean tracking, and fast pages are part of the blueprint, not an afterthought. Request a quote for your new website and let’s build something worth measuring.

Make It Function: Unlocking the Power of CSS Custom Functions

You know that one calc() you keep copy-pasting? The one with three nested var()s, a magic number, and a comment that says /* don't touch */? It lives in eleven places in your stylesheet, and every one of them is a slightly different mutation. CSS finally has a cure: CSS custom functions. You write the logic once with the @function at-rule, give it a name like --fluid-type(), and call it anywhere a value goes. No Sass build step, no JavaScript, no /* don't touch */.

When this draft was first written, custom functions were a spec-shaped rumor. They’re not anymore: Chrome shipped @function in version 139, and the syntax has settled enough to learn for real. Here’s how they work, where they’re supported, and how to use them today without breaking the site for everyone on Firefox.

What Are CSS Custom Functions?

A CSS custom function is a reusable recipe that takes inputs and returns a value. If CSS custom properties are labeled jars in your pantry (--brand: #7b2ff7), a custom function is the recipe card taped inside the cabinet door. The jar holds one thing. The recipe card says, “give me any color and an amount, and I’ll hand you back a perfectly tinted version.” Same kitchen, way less chopping.

They’re defined in the CSS Working Group’s CSS Functions and Mixins Module, which is still an Editor’s Draft. Here’s the smallest useful one, straight from the shipped syntax:

Basic @function:

@function --double(--value) {
  result: calc(var(--value) * 2);
}

.card {
  --space: 12px;
  padding: --double(var(--space)); /* 24px */
}

Three things to notice. The function name starts with two dashes, just like a custom property. Parameters are custom properties too (--value), which you read inside the body with plain old var(). And there’s no return keyword: the output is set with the result descriptor. If you learned this from the old speculative examples floating around, with $params and return, toss that recipe card. That was Sass cosplay.

Anatomy of a Recipe Card

Real recipes specify ingredients precisely, and so can you. Parameters can declare a type, a default value, and the function itself can declare what it returns:

Typed parameters, defaults, and return type:

@function --tint(--color <color>, --amount <percentage>: 20%) returns <color> {
  result: color-mix(in oklch, var(--color), white var(--amount));
}

.button {
  --brand: #7b2ff7;
  background: --tint(var(--brand));        /* uses the 20% default */
  border-color: --tint(var(--brand), 45%); /* overrides it */
}

The type sits right after the parameter name (<color>, <length>, <number>, and friends), the default comes after a colon, and returns goes before the opening brace. Need to accept more than one type? Use type(), as in --alpha type(<number> | <percentage>). Per MDN, if you pass an invalid argument to a parameter that has a default, the default is used instead. Pass a bad one to a parameter without a default, and the whole value goes invalid at computed-value time.

You can also stash locally scoped custom properties inside the body as constants. They stay in the function, like the secret ingredient Grandma never wrote down.

Local constants:

@function --anim-1s(--name, --count: 1) {
  --duration: 1s;
  --easing: ease-out;
  result: var(--name) var(--duration) var(--count) var(--easing);
}

.badge { animation: --anim-1s(pop, 2); }

Logic Inside: @media and if()

Here’s where it stops being fancy calc(). A function body can contain conditional at-rules like @media, and you can write several result descriptors. Normal cascade rules apply: the last one that applies wins. There are no early returns, so put your default first and the overrides after.

Responsive result with @media:

@function --narrow-wide(--narrow, --wide) {
  result: var(--wide);
  @media (width < 700px) {
    result: var(--narrow);
  }
}

.layout {
  grid-template-columns: --narrow-wide(1fr, 2fr 1fr);
}

That’s a media query tucked inside a value, which pairs beautifully with CSS Grid layouts. The same idea can be written with the new inline if() function, which Chrome shipped in version 137:

Same thing with if():

@function --narrow-wide(--narrow, --wide) {
  result: if(media(width < 700px): var(--narrow); else: var(--wide));
}

Note the syntax: condition, colon, value, then a semicolon before the next branch. No space between if and the parenthesis. if() can also test supports() and style() queries, which makes it a handy partner for theme switches like light and dark modes.

Recipes Worth Taping to the Cabinet

A few functions that earn their keep on real projects:

Fluid type helper:

@function --fluid(--min <length>, --max <length>, --vw <number>: 4) returns <length> {
  result: clamp(var(--min), calc(var(--min) + var(--vw) * 1vw), var(--max));
}

h1 { font-size: --fluid(2rem, 3.5rem); }
h2 { font-size: --fluid(1.5rem, 2.25rem, 3); }

That wraps clamp() so your responsive typography scale reads like a spec sheet instead of an algebra exam.

Transparent brand colors:

@function --alpha(--color <color>, --a <number>: 0.5) returns <color> {
  result: oklch(from var(--color) l c h / var(--a));
}

.card {
  box-shadow: 0 12px 32px --alpha(var(--brand), 0.25);
}

That one uses relative color syntax to make any token see-through, which is perfect for tinted CSS shadows that match your color palette instead of muddy gray.

Where Browser Support Stands

As of late October 2026, according to MDN’s browser compatibility data:

  • Chrome and Edge: @function supported since version 139; if() since 137.
  • Safari: @function is in Safari Technology Preview only; if() is not supported yet.
  • Firefox: neither @function nor if() is supported yet.

MDN still labels @function experimental and “Limited availability,” meaning it isn’t Baseline. And the “Mixins” half of the module, @mixin and @apply, is still being worked out in the draft spec and hasn’t shipped in any stable browser. So: real, usable, but not something every visitor gets. Time for some progressive enhancement.

Use Them Today Without Breaking Anything

The simplest fallback is the oldest trick in CSS: write the boring value first, then the fancy one. Browsers that don’t understand a dashed function treat that declaration as invalid and skip it, keeping the value above.

Cascade fallback:

.button {
  background: #9a5cf9;                /* everyone */
  background: --tint(var(--brand), 20%); /* browsers with @function */
}

For bigger chunks of styling, gate them behind @supports using a feature that shipped alongside functions. Since Chrome shipped if() before @function, testing for if() alone doesn’t prove functions work, so the per-declaration fallback above stays your safety net either way:

@supports gate for if():

@supports (color: if(else: red)) {
  .layout {
    grid-template-columns: if(media(width < 700px): 1fr; else: 2fr 1fr);
  }
}

Keep core layout and readability on the baseline path. Let functions polish things: nicer tints, smoother type scales, fewer repeated values. If the polish disappears in Firefox, nobody should notice anything except slightly less sparkle.

Pitfalls to Watch For

  • Silent failure. In supporting browsers, a type mismatch makes the value invalid at computed-value time, so you get the property’s initial or inherited value, not your fallback line. Check DevTools when a color suddenly goes transparent.
  • Order of results. Last applicable result wins. Put the default first, conditions after.
  • Commas in arguments. Passing a list like 1px, 7px, 2px as one argument? Wrap it in curly braces: --max-plus-x({1px, 7px, 2px}, 3px).
  • Scope surprises. Functions can see custom properties on the element where they’re called, and parameters override those. Name things clearly so --size doesn’t mean three things.
  • Name collisions. If two functions share a name, the one in the stronger cascade layer wins, then the later one in source order.
  • Not Sass. Functions run in the browser at computed-value time, per element. That’s the superpower (they react to the live cascade), but don’t expect loops, string building, or compile-time tricks.

Make It Function

CSS custom functions turn your stylesheet’s repeated math into named, typed, reusable recipes, and they’re already live in Chromium browsers. Learn the real syntax (@function, --name(), result), lean on fallbacks, and keep an eye on Safari and Firefox as they catch up. Your future self, the one who no longer has to edit eleven calc()s, says thanks.

Building a new site and want it engineered with modern, maintainable CSS from day one? Get a custom web design quote and let’s cook up something great.

Bot or Not? How to Spot and Filter Bot Traffic in GA4

You open Google Analytics on a Monday morning and there it is: a traffic graph shaped like a hockey stick. Sessions are up 400%. For about four seconds you feel like a genius. Then you notice your new biggest market is Lanzhou, China, nobody stayed longer than zero seconds, and every one of these “visitors” showed up through Direct with a landing page of (not set).

Congratulations, you have bot traffic in GA4. You are in good company. It is one of the most common complaints in analytics circles this year, and the good news is that it is usually harmless to your site and very fixable in your reports.

Think of your analytics as a guest book at a wedding reception. Most signatures belong to real guests. But somebody left the door open, and now a busload of mannequins has been wheeled through, each one “signing” the book on the way past. They didn’t eat the cake. They didn’t dance. They just make the headcount look amazing. Your job isn’t to panic about the mannequins. It’s to learn what a mannequin signature looks like, stop counting them, and maybe put a bouncer at the door.

What GA4 Already Filters (and What It Doesn’t)

First, some credit where it’s due. According to Google’s known bot-traffic exclusion documentation, GA4 automatically excludes traffic from known bots and spiders, using Google’s own research plus the IAB’s International Spiders and Bots List. You can’t turn it off, and you can’t see how much it excluded.

The key word is known. Polite crawlers that identify themselves get caught. Bots that run a real headless browser, execute your Google Analytics tag, and pretend to be Chrome on Windows walk right past the velvet rope. So do spammers who fire fake hits straight at GA without ever touching your site.

The Telltale Signs of Bot Traffic

Mannequins are easy to spot once you know what to look for. Here are the fingerprints showing up most often in 2026:

  • Sudden Direct or Unassigned spikes. A big jump in Direct (or Unassigned) sessions that starts and stops abruptly, often with no matching bump in leads or sales.
  • Landing page “(not set)”. The session started, but no proper page_view with a page location came along. Real browsers rarely do that in bulk.
  • Weird cities. Lanzhou and Singapore have been the headline acts; WIRED reported that traffic traced back to cloud networks rather than actual residents. Data-center towns like Boardman, Oregon and Ashburn, Virginia (home to huge AWS footprints) are classic suspects too.
  • Zero engagement. Engagement rate near 0%, average engagement time measured in fractions of a second, and one page per session.
  • Suspicious sameness. 99% desktop, one browser, one operating system, one screen resolution. Humans are messier than that.
  • Referral spam. Referrals from domains you’ve never heard of, sometimes with a “visit my SEO service” vibe, that never seem to send anyone who actually reads anything.

Search Engine Watch described a September 2026 wave where Singapore sessions jumped ninefold in a day with a 0% engagement rate and about half a second per session. Some newer bots are getting better at faking human-looking behavior, so don’t rely on one signal. Look for a cluster of them.

Investigate With an Exploration

Standard reports will show you the spike. An Exploration will show you who’s behind it. Go to Explore, start a Free form exploration, and build a table like this:

Exploration recipe: "Who are these people?"

Rows:     Session default channel group
          City
          Landing page + query string
Columns:  Device category
Values:   Sessions
          Engaged sessions
          Average engagement time per session
Filter:   Session default channel group exactly matches Direct
Date:     The spike, plus a normal week before it

Then swap in Browser, Operating system, Screen resolution, and Hostname as rows. If one combination accounts for most of the spike, and its engagement is basically zero, you’ve found your mannequins. Hostname is especially useful: if hits are arriving for a domain that isn’t yours, that’s spam sent straight to your measurement ID rather than visits to your site.

Hide the Noise in Your Reports

Once you know the pattern, you have a few non-destructive ways to look past it:

  • Comparisons. In standard reports, add a comparison that excludes the suspicious city or country. Great for a quick “what does reality look like?” check.
  • Segments. In Explorations, build a session segment that excludes the bot fingerprint (say, City is Lanzhou, or Screen resolution equals that one suspicious value with zero engagement). Reuse it any time you analyze.
  • Report filters. Google itself recommends report filters when you want to hide data without permanently removing it.

These views are reversible, which matters. If you exclude all of Singapore and you actually have customers there, you can simply undo it.

Data Filters: Powerful, Permanent, and Picky

GA4 also has data filters, which stop matching events from being processed at all. Here’s the fine print you need to know before reaching for them:

  • They only work going forward. Data filters don’t affect historical data. GA4 can’t retroactively delete last week’s bot spike.
  • Exclusions are permanent. Excluded data is never processed and won’t show up in GA or BigQuery later. Always run a filter in Testing state first.
  • The menu is short. The filter types are Developer traffic, Internal traffic (by IP address), and, more recently, Web hostname traffic. There’s no “exclude Lanzhou” or “exclude screen resolution” data filter.

Internal and developer filters are still worth setting up, because your own team’s visits are a different flavor of noise. Define your office IPs under your web data stream’s tag settings (Define internal traffic), then activate the Internal traffic filter under Admin → Data collection and modification → Data filters. If you see spam arriving for strange hostnames, a hostname filter that includes only your real domain(s) is the best defense GA4 offers against fake hits.

What About Unwanted Referrals?

GA4’s List unwanted referrals setting (in your web stream’s tag settings) sounds like a spam filter, but it isn’t. It tells GA4 not to credit certain domains as referrers, which is meant for things like payment processors bouncing shoppers back to your checkout. It doesn’t delete the sessions. Use it for legitimate third-party hops, and use segments or report filters for spam.

Check the Door, Not Just the Guest Book

GA4 only sees visitors that run your tag. To see what’s really knocking, cross-check with your CDN or server. If your site sits behind Cloudflare, its traffic and security analytics show requests by country, ASN, and user agent, and paid plans add Bot Analytics with bot scores. Cloudflare’s CDN layer is also where you can actually block or challenge bad traffic with a rule, before it ever reaches your site:

# Cloudflare custom rule (expression) → Action: Managed Challenge
(ip.src.country eq "SG" and not cf.client.bot)

Adjust that to whatever your Exploration revealed, and only challenge regions you don’t actually serve. Your web host‘s raw access logs are the other source of truth: a burst of requests from one cloud provider’s IP range with one user agent tells you more than any GA dashboard can.

AI crawlers are a related but separate headache. Most of them don’t run JavaScript, so they rarely show up in GA4 at all, but they do show up in your logs and bandwidth bill. I wrote a separate guide on which AI crawlers to block with crawl rules and robots.txt.

Common Pitfalls

  • Excluding whole countries forever. Fine as a report view, risky as a habit if you sell internationally.
  • Skipping the Testing state. A sloppy data filter can permanently delete real data. Test first.
  • Blaming SEO. Bot hits in GA4 don’t hurt your rankings. Keep an eye on Google Search Console for real search performance.
  • Assuming it’s always bots. A broken tag, consent banner change, or slow-firing session_start can also produce Unassigned or (not set) data. Check your setup before you blame the robots.
  • Ignoring your forms. If bots are filling out your contact form too, that’s a security problem, not just an analytics one.

Count the Guests, Not the Mannequins

Bot traffic in GA4 is annoying, but it doesn’t have to ruin your data. Recognize the fingerprints, isolate them with an Exploration, hide them with segments and comparisons, use data filters carefully for what they can handle, and stop the worst offenders at the door with Cloudflare or your server. Then annotate the spike so future-you doesn’t spend another Monday morning wondering if you went viral in Lanzhou.

Planning a new site and want it built with clean analytics, sensible filters, and bot protection from day one? Request a custom web design quote and let’s make sure your numbers tell the truth from launch.

Which AI Crawlers to Block (and Which Ones Send Customers)

Picture your website as a small bakery. Most mornings, the people at the door are customers. Lately, though, there are other visitors. A food critic shows up, takes notes, and writes you into a guide that sends hungry people your way. A personal shopper comes in to grab one loaf for a customer who asked for it. A culinary school sends a student with a notebook to copy every recipe on the wall for a class you will never see. And every now and then, somebody walks in, asks to sample everything, and does it two thousand times an hour.

They are all “visitors.” Only some of them bring in business. That is the whole question behind whether you should block AI crawlers: not “AI, yes or no,” but which of these people you want in your bakery.

Why Your Logs Suddenly Look Like a Bot Convention

You are not imagining it. Cloudflare Radar put bots at 57.5% of requests for HTML pages across its network, the first time automated traffic outnumbered humans on that measure (as reported by Forbes). That is an aggregate across a huge slice of the web, not a promise about your site, but it explains why your server stats feel busier than your phone.

The anecdotes are more pointed. One small-site owner shared on X that Google read their site 43 times and sent 145 visitors, while AI bots read it 6,051 times and sent 16. Another said they blocked AI crawlers after watching ClaudeBot make more than 2,000 requests in an hour. Those are single sites, not studies. Still, they capture the frustration: a lot of reading, not much referring.

The fix is not to slam the door on everything with “bot” in its name. It is to sort the visitors.

Meet the Three Kinds of AI Bots

Most of the big AI companies now split their bots by job, and they document that split. Roughly, there are three kinds:

  1. Search crawlers (the food critics). These index pages so an AI search product can show and link to them. Blocking them can make you disappear from those answers.
  2. User-triggered fetchers (the personal shoppers). A person asks a chatbot about something, and it fetches a page right then. These aren’t broad crawls, and several vendors say robots.txt may not apply to them because a human started the request.
  3. Training crawlers (the culinary students). These collect content that may be used to train future AI models. Blocking them is an opt-out from training, and per the vendors, it doesn’t remove you from their search features.

Here is how the major names sort out, according to each company’s own documentation as of October 2026:

Keep these allowed if you want to be found:

  • Googlebot and Bingbot: classic search. Block these and you’re blocking your own SEO.
  • OAI-SearchBot: OpenAI says it is used to surface sites in ChatGPT’s search features, and opted-out sites won’t show in ChatGPT search answers.
  • ChatGPT-User: fetches pages when a ChatGPT user asks. OpenAI notes robots.txt rules may not apply, and it isn’t used to decide search inclusion.
  • Claude-SearchBot and Claude-User: Anthropic says disabling either may reduce your visibility in Claude’s search results and user-directed lookups.
  • PerplexityBot and Perplexity-User: Perplexity says PerplexityBot surfaces and links sites in its results and isn’t used to crawl content for AI foundation models. Perplexity-User generally ignores robots.txt since a person requested the fetch.
  • Applebot: powers search in Spotlight, Siri, and Safari, per Apple.

Your call (training crawlers):

  • GPTBot (OpenAI): crawls content that may be used to train its generative AI foundation models.
  • ClaudeBot (Anthropic): collects content that could contribute to model training.
  • CCBot (Common Crawl): builds an open web archive that a lot of researchers and AI developers draw from.
  • Google-Extended: not a separate crawler, just a robots.txt token. Google says it controls whether content may be used to train future Gemini models and for grounding in Gemini Apps and Vertex AI, and that it doesn’t affect Google Search inclusion or ranking.
  • Applebot-Extended: also a control token, not a crawler. It opts you out of training Apple’s foundation models while regular Applebot keeps you in Apple search.
  • meta-externalagent (Meta): Meta says it crawls for uses such as training AI models or indexing content directly.
  • Bytespider (ByteDance): appears in Cloudflare’s AI crawler analytics, but I couldn’t find a current official ByteDance page describing it, so treat it as an AI crawler you manage at the CDN.

GPTBot vs OAI-SearchBot: The Distinction That Matters Most

If you only remember one thing, make it this. GPTBot vs OAI-SearchBot is the difference between “train on my stuff” and “show my stuff to people searching in ChatGPT.” OpenAI’s docs say the two settings are independent, so you can disallow GPTBot and still allow OAI-SearchBot.

A lot of the “block AI bots” robots.txt snippets floating around list every AI-sounding name in one big Disallow block. That is the robots.txt equivalent of locking out the food critic because you were annoyed with the culinary student. If you want your business to show up when someone asks ChatGPT for a web designer in Davenport, a blanket block works against you.

A Robots.txt for ChatGPT (and Friends) That Keeps the Door Open

Here’s a sensible starting point for a small-business site that wants to stay findable in search and AI answers but opt out of model training. Your robots.txt lives at the root of your domain, right next to the XML sitemap it should point to.

robots.txt: opt out of training, stay in search

# Training crawlers and tokens: opted out
User-agent: GPTBot
User-agent: ClaudeBot
User-agent: CCBot
User-agent: Google-Extended
User-agent: Applebot-Extended
User-agent: meta-externalagent
Disallow: /

# Everyone else (Googlebot, Bingbot, OAI-SearchBot,
# Claude-SearchBot, PerplexityBot, Applebot...): welcome
User-agent: *
Allow: /

Sitemap: https://example.com/sitemap.xml

A few notes so this doesn’t bite you later:

  • Grouping several User-agent lines over one rule is valid, but a bot that matches a named group ignores the * group. If you also keep Disallow: /wp-admin/ style rules under *, copy them into any named group you add.
  • If you’d rather be in the training data (some brands want models to know them), delete that first block. That’s a legitimate choice, not a mistake.
  • On WordPress, the robots.txt is usually virtual. SEO plugins such as Yoast and Rank Math include a robots.txt editor, or your host can place a physical file. If you use Cloudflare, it also offers a managed robots.txt option.

robots.txt is a “Please Don’t Feed the Ducks” sign. Most visitors read it. The ducks were never going to.

Robots.txt Is a Request, Not a Lock

This is where people overestimate the file. robots.txt is a public, polite request. Well-behaved crawlers from OpenAI, Anthropic, Google, Apple, Common Crawl, and Meta say they honor it. Anything that ignores it, or simply pretends to be one of those bots by faking its user agent, walks right past. Common Crawl explicitly warns that some crawlers falsely identify themselves as CCBot.

Also note the fine print above: the user-triggered fetchers (ChatGPT-User, Perplexity-User, Meta-ExternalFetcher) may not follow robots.txt at all, because a person asked for that page. That’s usually fine. It’s one page, for one person, roughly like a browser visit.

So robots.txt handles intent. For behavior, like a crawler hammering your server, you need something that actually enforces. Same lesson as protecting your WordPress site from hackers: signs are nice, locks are better.

When a Bot Gets Greedy, Handle It at the CDN

If you’re behind a content delivery network like Cloudflare, the edge is where to deal with abusive traffic, before it ever reaches your server or your hosting bill.

Cloudflare AI Crawl Control shows which AI crawlers are hitting your site, how many requests they make, and, per Cloudflare’s docs, how often each one violates your robots.txt. You can set each crawler to Allow or Block, and blocking creates a WAF rule for you. The docs even suggest allowing crawlers that “provide value through citations, referrals,” which is the same food-critic logic.

If a bot you want to keep is simply too eager, rate-limit it instead of banning it. In Cloudflare, that’s a rate limiting rule with an expression like this:

Cloudflare rate limiting rule: expression (example)

(http.user_agent contains "ClaudeBot") or
(http.user_agent contains "Bytespider")

Pair it with a sensible threshold for a small site (say, a few dozen requests per minute) and an action like Block or Managed Challenge for the cooldown period. Pick numbers based on your own traffic, not mine.

Not on Cloudflare? Many hosts and security plugins offer rate limiting too. If your current hosting provider can’t tell you who’s eating your bandwidth, that is worth knowing on its own. Anthropic also supports the non-standard Crawl-delay line for ClaudeBot. Apple says Applebot doesn’t follow it, so don’t lean on it as your only control.

What to Expect After You Change Things

Nothing here is instant. Crawlers cache robots.txt: OpenAI says it can take about 24 hours for its search systems to adjust after a robots.txt change, Perplexity says up to 24 hours, and Meta says the same. Training opt-outs apply going forward, not retroactively, to content already collected.

And allowing search bots is not a guarantee. Being crawlable makes you eligible for AI citations, the same way being indexed makes you eligible to rank. Whether an assistant actually mentions you still depends on whether your pages answer the question clearly. Keep an eye on referrals in your analytics and in Google Search Console, and judge over months, not days.

The Short Version

  • Keep search and answer bots allowed: Googlebot, Bingbot, OAI-SearchBot, Claude-SearchBot, PerplexityBot, Applebot.
  • Decide on training crawlers on purpose: GPTBot, ClaudeBot, CCBot, Google-Extended, Applebot-Extended, meta-externalagent.
  • Use robots.txt to state your preferences, and your CDN or WAF to enforce them.
  • Rate-limit a greedy bot before you ban a useful one.

Keep the Critics, Mind the Notebooks

Your bakery doesn’t need a bouncer who turns away everyone in a lanyard. It needs a door policy: critics welcome, personal shoppers fine, recipe copiers by invitation, and the two-thousand-samples-an-hour guy gets walked out.

If you’d like a second set of eyes on your robots.txt, CDN settings, or whether AI search is actually sending you anyone, that’s the kind of thing we set up for clients at Photricity. Request a quote and we’ll take a look.

Congrats on the New Website — Now Brace for the Spam

So your website is live, it looks great, and Google has noticed it. Unfortunately, so has everyone else with a mailing list and no conscience.

Within weeks of launching a site (or after a big SEO win), many business owners start getting official-looking letters, urgent emails, and phone calls from people who “just happened” to find their website. They did not just happen to find it. Domain registration data, business directories, and website scrapers make it easy to build a target list, and a fresh, visible site goes straight to the top.

Here is a field guide for what to expect, and what to do about it.

The “Domain Expiration Notice” Letter

Domain registration solicitation

This one arrives in the mail and looks very official. It lists your real domain name, an expiration date, a deadline, a payment slip, and often a QR code. It warns that you could lose your online identity if you do not act now. Recent versions ask for around $265 for a five-year “renewal.”

Here is the catch: it usually is not from your registrar at all. It is a solicitation to transfer your domain to the sender, often at several times the going rate. The fine print tends to say something like “this is not a bill.” This tactic is called domain slamming, and the FTC went after one of its best-known practitioners years ago. The copycats never left.

How to check: Log in to the registrar where you actually bought your domain (GoDaddy, Namecheap, Squarespace, etc.) and look at the expiration date there. If the sender is not that company, you owe them nothing. Not sure where your domain is registered, or who handles your DNS records? Ask your web developer before you pay anyone.

Bonus move: Turn on registrar lock (transfer lock) and auto-renew for your domain.

The Friendly SEO Email

You know the one:

  • “I took a look at your website and found several issues hurting your ranking.”
  • “We can get you on page one of Google in 30 days. Guaranteed.”
  • “Your competitors are outranking you.”

The tells: The email never mentions anything specific about your site, your town, or your keywords. The list of “problems” is vague jargon (missing meta tags, poor image optimization) that could be pasted into any email to any business. And nobody, anywhere, can guarantee a ranking. Google says so itself.

If you get one, ask two questions: Which keywords, in which city, against which competitors? And can I see a client you have worked for? Real SEO professionals can answer. Mass-mailers go quiet.

Want to know how your site is really doing? You can see it for yourself, for free, in Google Search Console and Google Analytics. No cold email required.

(Quick sanity check: if you search your own business name and you are already on page one, congratulations, that is not a service you need to buy.)

The “Google Listing” Phone Call

Google business listing telemarketing call

The caller says they are with Google, or “Google Business Services,” and that your listing is about to be removed, needs verification, or can be bumped to the top of the map results. A robot voice may tell you to press 1 to continue.

What’s more, the call may even come from your local area code.

Google’s own guidance is clear: they will never ask for payment to keep, verify, or reinstate your Business Profile, and they will never guarantee you a special spot in search or Maps. They also will not ask for a PIN or one-time code.

What to do: Hang up. Do not press any buttons, even if the voice tells you to. If someone insists they work at Google, ask them to email you from an @google.com address. (They will not.)

The Fake Invoice and the “Free” Directory Listing

The FTC warned small businesses about this in May 2026: fake invoices for things you never ordered, like domain registration, SEO, or tech support. Some arrive as “past due.” Some look like they are from big names. Whoever handles your bills is the target, hoping they will just pay it.

A close cousin is the directory listing scam. A call or letter says you are being listed (for free, or as a “renewal”) in a business directory. A bill shows up later, along with a claim that you agreed to it. If you never agreed, do not pay.

Rule of thumb: Do not pay any invoice for a service you cannot connect to a person who actually sold it to you. Search the company name plus “scam,” “review,” or “complaint” first.

Someone Pretending to Be Your Web Designer or Host

Scammers can read a web designer’s portfolio page, collect the contact email from each client’s site, and send messages that look like they came from the designer. They say your site “is not compliant,” your plugins or hosting are “due for renewal,” or your account will be suspended in 48 hours. The goal is payment, or your WordPress or hosting login.

What to do: Do not click the link or call the number in the message. Contact your designer or host using a phone number or email address you already have. And never enter your credentials on a page you reached from an email.

Spoofed email is a big part of this one. It is worth reading up on securing your domain email with SPF, DKIM, and DMARC, and on protecting your WordPress site from hackers. Regular website maintenance also means you will know what is actually due and when.

The Quick Red Flag Checklist

  • Urgency. “Act now,” “final notice,” “48 hours.”
  • Guarantees. Rankings, results, or “priority” with Google.
  • Payment pressure. Gift cards, wire transfers, QR codes, or “pay to avoid suspension.”
  • Vague specifics. No mention of your actual site problems, or generic “errors.”
  • Wrong sender. Not the company you actually do business with.
  • Fine print that contradicts the headline. “This is not a bill.”

What to Do When One Shows Up

  1. Pause. Scammers rely on you reacting before thinking.
  2. Verify independently. Log in to your registrar, host, or Google account directly. Do not use links or phone numbers from the message.
  3. Do not engage. Replying, pressing buttons, and scanning QR codes confirm that your contact info is live.
  4. Tell whoever pays the bills. A one-line policy helps: we never pay anything domain-, SEO-, or Google-related unless it goes through our known vendors.
  5. Report it.
  6. FTC: ReportFraud.ftc.gov (phone scams and fake invoices)
  7. Phishing emails: [email protected]
  8. Scam texts: forward to 7726 (SPAM)
  9. Fake Google calls: report through Google Business Profile Help
  10. Do Not Call Registry: donotcall.gov (it will not stop scammers, but it is worth having)

Not Sure About Something?

When in doubt, do not pay, click, or call back. Send it to your web developer, your IT person, or a trusted friend who knows their way around the internet and ask for a second opinion first. A quick look usually settles it, and it is a lot cheaper than a five-year “renewal” from a company you have never heard of.

Introducing Evertongue: Multilingual WordPress That Scales

“Every tribe and tongue and people and nation.” (Revelation 5:9)

Most multilingual WordPress plugins work well for two or three languages. At ten or twenty, the language switcher is a wall of links, the admin is cluttered, and keeping translations in sync takes more effort than writing them.

Evertongue is a WordPress translation plugin built for sites with many languages. It is free, lightweight, and available on WordPress.org.

Why we built it

We built Evertongue with ministry and mission work in mind. Some of those sites need to reach people in dozens of languages from one WordPress install, such as discipleship courses, Bible resources, and outreach material.

The tools we tried were either too heavy or too narrow. We wanted something that felt like WordPress and stayed manageable as the language list grew.

How it works

Evertongue dashboard

Every translation is a real WordPress page or post. Evertongue doesn’t hide translations in custom tables or serialized blobs. A French version of your Contact page is an ordinary page that you edit with the block editor you already know. Your page builder, custom fields, and SEO plugin all work as usual.

The URLs are simple. Your default language lives at the site root and every other language gets a prefix:

  • example.com/contact/
  • example.com/es/contact/
  • example.com/fr/contact/

Slugs stay identical across languages, so links are predictable and easy to share.

What you get

Page and post translation

Create a translation from the editor sidebar. Evertongue copies the content and custom fields into a new draft in the target language, and you replace the text. The pages list shows at a glance which languages exist for each page.

Theme and site string translation

Buttons, form labels, and other theme text are captured automatically as visitors and editors browse the site. You choose which strings to manage and translate them in one place. A progress view shows how complete each language is.

Shortcodes and custom strings

Every managed string gets a copyable shortcode, such as [evt_string id="42"]. Paste it into a page and it shows the right language for each visitor. You can also create custom strings for phrases that don’t come from your theme, such as a recurring call to action or a block label.

Identical phrases found in different places on the site can be merged into one string. They then share one translation and one shortcode, so you update the wording once.

Language switchers that handle large lists

Evertongue combobox language switcher

Use the Language picker block, a floating button, a footer list, or a template tag. The searchable dropdown stays usable at 50 languages. The block supports alignment, colors, borders, radius, padding, and shadow. It can also hide languages that have no translation of the current page.

Two translation modes

  • Full site: translated menus, theme strings, text direction, and language attributes all follow the visitor’s language.
  • Content-only: translate pages and posts and leave the rest of the site alone. This is a good fit when you only need a few translated pages.

Built for real-world teams

  • Right-to-left support for languages such as Arabic and Hebrew
  • Role-based permissions. Choose which roles can translate and which can manage settings, right from the Settings screen.
  • Inactive languages. Keep a language out of the picker while you finish it. Anyone with the URL can still see it, so you can test it live.
  • Setup mode. Import and prepare content before your multilingual URLs go public.
  • SEO. hreflang alternate links and og:locale tags are added automatically.

Migration and portability

  • Importers for WPML and Polylang
  • PO file import and export, so translators can work in tools they already use
  • CSV import for adding many languages at once

Where it fits

Evertongue is a good fit if you:

  • Need to serve many languages without a bloated admin
  • Want translations to be ordinary WordPress content
  • Run a ministry, nonprofit, or educational site with a lot to translate
  • Want simple URLs and a front end with no unnecessary overhead

It is probably not the right tool if you want automatic machine translation, or an all-in-one localization suite with every integration built in. Evertongue keeps its scope small and its foundation clean, so it stays understandable and fast.

Get started

  1. Install Evertongue from the WordPress plugin directory.
  2. Add your languages under Evertongue → Languages, or import a CSV.
  3. Pick your translation mode in Settings.
  4. Translate a page from the editor sidebar.
  5. Turn off setup mode when you’re ready to go live.

If you reach people across language barriers, Evertongue gives your message a way to travel with it.

Questions or feedback? Reach out at photricity.com/contact.

Mastering CSS Shadows: From Subtle Glows to Dramatic Depth

Ever stared at a webpage and thought, “Why does this feel so flat?” Or flipped it—marveled at a design that practically leaps off the screen? Chances are, shadows are the unsung heroes (or culprits) behind it. CSS shadows—those sneaky little box-shadow and text-shadow properties—are more than just decorative fluff. They’re the secret sauce for depth, hierarchy, and that oh-so-satisfying tactile vibe.


Shadows 101: What Are We Working With?

box shadow example

CSS gives us two main tools for shadow-casting: box-shadow for elements and text-shadow for, well, text. Think of them as the salt and pepper of web design—small additions that can transform the flavor of your layout. A basic box-shadow might look like this:

.shadow-box {
  box-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
}

That’s a simple shadow—2px right, 2px down, 4px of blur, and a semi-transparent black. Slap it on a <div>, and boom: instant depth. Meanwhile, text-shadow does the same for typography:

text shadow example
.fancy-text {
  text-shadow: 1px 1px 2px #666;
}

Shadows are like ninjas—quietly enhancing your design without stealing the spotlight. But to wield them effectively, you need to know their anatomy.

Dissecting the Shadow

The box-shadow syntax is a playground of possibilities: offset-x, offset-y, blur-radius, spread-radius, and color. Each piece tweaks the shadow’s behavior. Let’s break it down:

  • Offset-x and Offset-y: Where the shadow lands relative to the element—like “2px over, 3px down.”
  • Blur-radius: How soft the edges get. Zero is crisp; 10px is a dreamy haze.
  • Spread-radius: The shadow’s size. Positive values puff it out; negative ones shrink it inward.
  • Color: Pick your poison—hex, RGB, or RGBA for transparency.

Here’s a tweakable example:

.shadow-play {
  box-shadow: 5px 5px 10px 2px rgba(0, 0, 0, 0.4);
}

Mess with those numbers, and you’ll see the shadow stretch, blur, or sharpen. Text-shadow is simpler—same offsets and blur, no spread—but just as powerful. Shadows aren’t static; they’re dynamic tools begging for experimentation.

Everyday CSS Shadows: Practical Wins

Shadows aren’t just for show—they solve real design problems. Here’s where they shine:

Subtle Elevation

Want that Material Design vibe? A light box-shadow lifts buttons and cards off the page. Try this:

.card {
  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
  transition: box-shadow 0.3s ease;
}
.card:hover {
  box-shadow: 0 6px 12px rgba(0, 0, 0, 0.2);
}

It’s subtle, but it screams “click me.” Many sites use this trick to make thumbnails feel grabbable.

Text That Pops

Over a noisy background? Text-shadow saves the day:

.hero-text {
  text-shadow: 0 2px 4px rgba(0, 0, 0, 0.5);
}

Suddenly, your white text on a gradient is legible. No squinting required.

Interactive Feedback

Hover effects with shadows feel alive. Pair them with transition, and you’ve got smooth, delightful motion. It’s the difference between a button that sits there and one that invites you in.

Level Up: Creative CSS Shadow Techniques

Now, let’s push the boundaries. CSS shadows can do more than “slightly raised.” They can dazzle.

Layered Shadows

Stack multiple shadows for a neon glow or realistic depth. Check this out:

neon glow example
.neon-button {
  box-shadow: 
    0 0 5px rgba(255, 0, 0, 0.7),
    0 0 20px rgba(255, 0, 0, 0.5),
    0 0 40px rgba(255, 0, 0, 0.3);
}

That’s a button pulsing with sci-fi energy. Layering is your ticket to wow-factor.

Inner Shadows

Flip the script with inset:

inset shadow example
.pressed {
  box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.3);
}

It’s perfect for a “clicked” effect—think sunken buttons or carved-out panels.

Long Shadows

For a flat-design twist, use multiple shadows to create a diagonal stretched shadow effect:

stretched shadow effect
.long-shadow {
  box-shadow: 5px 5px 0 #ccc, 10px 10px 0 #ccc, 15px 15px 0 #ccc;
}

It’s retro, it’s bold, and it’s a conversation starter.

Watch Out: Shadow Pitfalls to Dodge

Shadows are awesome—until they’re not. Here’s how to avoid facepalms:

Performance Hits

A page with 50 elements rocking heavy box-shadows can chug like an old laptop. Blur and spread are GPU-intensive, so keep it lean on large layouts.

Overdesign Syndrome

Piling on too many shadows can make your site look like a haunted house at midnight. Less is often more—use shadows to enhance, not overwhelm.

Accessibility Snags

Text-shadow can muddy contrast. If your text blends into the background, you’ve got an accessibility fail.

Pro Tips: CSS Shadows That Slap

Ready to flex? These tricks will make your shadows stand out:

  • RGBA Transparency: Soften edges with rgba(0, 0, 0, 0.2). It’s gentler than solid black.
  • CSS Variables: Dynamic shadows for themes? Yes, please:
:root {
  --shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
}
.card {
  box-shadow: var(--shadow);
}

Switch --shadow for dark mode in one line. Efficient and cool.

  • Drop-Shadow Filter: For SVGs or irregular shapes, filter: drop-shadow(2px 2px 4px #000) follows the contours where box-shadow can’t.

Hands-On: Build a Shadow-Powered Card

Let’s put it all together. Here’s a sleek card with hover magic:

.shadow-card {
  width: 300px;
  padding: 20px;
  background: white;
  border-radius: 8px;
  box-shadow: 
    0 4px 6px rgba(0, 0, 0, 0.1),
    0 1px 3px rgba(0, 0, 0, 0.08);
  transition: box-shadow 0.3s ease, transform 0.3s ease;
}
.shadow-card:hover {
  box-shadow: 
    0 7px 14px rgba(0, 0, 0, 0.1),
    0 3px 6px rgba(0, 0, 0, 0.08);
  transform: translateY(-5px);
}

Pair it with this HTML:

<div class="shadow-card">
  <h2>CSS Shadows Rock</h2>
  <p>Hover me for some depth!</p>
</div>

Shadow Play Is Your Superpower

CSS shadows are deceptively simple yet endlessly versatile. They can whisper “click here” with a soft lift, scream “look at me” with a neon glow, or just make text readable on a chaotic backdrop. Whether you’re a minimalist or a maximalist, shadows are your playground.

So, go experiment. Cast some shadows. Break the rules, then fix them. Next time you’re polishing a design, you’ll know exactly how to make it pop.