Posts
Practical pieces on structure, voice, and shipping content for the web.
Hardcode your footer links in the template
Footer links change once a year, if that. Stop treating them like editable content.
Publish status labels need unambiguous verbs
Draft, pending, and scheduled sound like they mean something—until three people interpret them three different ways.
Your homepage intro paragraph is probably backwards
Most homepages bury the essential information in sentence three. Start with what people came to find out.
Button text should match the action you're confirming
When your confirmation dialog asks "Delete this page?" and the button says "OK," users hesitate. Match the verb to close the gap.
Run a content audit before you change your CMS
Migrating platforms without knowing what you have means migrating problems. Audit first, then decide what moves.
Conditional field display breaks your content model
Hiding fields based on other field values creates phantom dependencies that break bulk editing, API calls, and future migrations.
Field labels need a verb when the field isn't obvious
A noun alone works for "Email" or "Phone." Everything else requires instruction.
Stop apologizing in your confirmation messages
Users who just completed an action don't need reassurance that you're sorry for the interruption. They need confirmation of what happened.
Tag taxonomies fail when you can't explain the difference
If two tags overlap enough that you pause before choosing, you don't have a taxonomy—you have a list of synonyms slowing down your workflow.
Error messages need specific recovery instructions
Generic error copy forces users to guess what went wrong and how to fix it. Your error message should tell them exactly what to do next.
Menu labels belong in user vocabulary, not yours
Navigation reflects how your team talks about content, not how users think about finding it. Fix that before you publish.
Alt text describes the image, not the metaphor
Writing alt text isn't about explaining what your image represents — it's about describing what's actually visible in the frame.
Empty states need their own interface copy
When a page has no content to display yet, what you show matters more than the layout waiting to be filled.
Disable comments field-by-field, not site-wide
Turning off comments globally wastes the structure you already built. Control it where the content model decides.
Date metadata shapes how users filter your content
Publication dates aren't just timestamps. They determine how people navigate archives, sort results, and decide what's current.
Test your search with what people actually type
Your site search only works if it returns results for the words users choose, not the terms you wish they'd use.
Placeholder text teaches users to ignore your interface
When every field shows example content before anyone types, people stop reading what's actually there. Placeholder text becomes invisible faster than you think.
Write captions for images when you add them
A caption field left empty at upload time stays empty. Write it when the context is still in your head.
Version numbers belong in your file names
If you're saving files as final-FINAL-v3-actual.jpg, you've already lost. Name versions so you can find the current one without opening twelve candidates.
Excerpts aren't summaries of everything the post says
An excerpt sells the click. A summary recaps what someone already read.
Link previews show what you chose to highlight
When you share a URL, the preview card pulls from your meta tags. Control what shows up before someone else does it for you.
Scheduled publish dates require a rollback plan
Setting content to go live at a specific time isn't just a calendar event. You need a documented process for pulling it back if something changes.
Preview text isn't optional for email newsletters
The line that shows up next to your subject line in an inbox does work whether you write it or not. You should write it.
Archive pages need their own navigation rules
Pagination, filters, and sort controls follow different patterns than your main menu. Decide how users move through lists before you template them.
Reusable content blocks need names users recognize
When you create modular content components, label them for the people who'll actually pick them from a dropdown, not for your internal architecture diagram.
Image dimensions belong in your content model
If you're resizing uploaded images on the fly, you've already made decisions about aspect ratio and display context. Codify them before the next upload.
Define your content types before you write content
A content type is a template for similar pages. Decide what fields each type needs before anyone starts filling them in.
Field order is the first draft of your content hierarchy
The sequence you build your CMS fields in trains users where to look first. Don't let alphabetical sorting or feature creep decide that for you.
Pick one publication date field and stick with it
Multiple date fields in your CMS create confusion about which one matters. Choose the field that governs visibility, then make everything else follow it.
Log when you publish, not just what you publish
A timestamped record of what went live—and when—gives you a reference layer that CMS change logs and analytics timestamps can't replace.
Decide your URL structure before you create content
Your URL pattern shapes how users navigate, how search engines index, and how you maintain your site. Choose it once, early, and stick to it.
Inline examples belong in help text, not field labels
Field labels identify what users enter. Help text shows them how to format it.
Copy link text from the page it points to
Your link anchor should match the destination page's actual heading or title. Inventing paraphrase just creates friction.
Label your form sections before you add the fields
Form sections with clear labels help users understand what you're asking before they start filling things out. Name the section, then build what goes inside it.
Breadcrumb trails need a consistent depth model
Your breadcrumb navigation only works if you've already decided what counts as a level. Bolt the hierarchy first, then surface it.
Decide which fields are searchable before you build search
Search indexes don't magically know what matters. You decide which fields users can search, and which they can't.
Inline links need surrounding context, not just anchor text
You can't write a useful inline link without writing the sentence around it. The anchor text alone won't carry the meaning.
Subheadings announce content, not curiosity
A subheading that makes readers guess what's next isn't clever — it's friction. Write the summary sentence, then trim it to fit.
Your CMS rich text editor isn't a word processor
Stop treating the WYSIWYG editor like Microsoft Word. The formatting buttons you ignore now determine whether your content survives template changes, mobile layouts, and CMS migrations.
Heading hierarchy isn't negotiable typography
Skip an H-level and you've broken the document outline, regardless of how it renders. Screen readers, search crawlers, and accessibility audits all rely on proper nesting.
Body copy isn't the place to introduce your page
The first paragraph of your page should do work, not warm up. Start after the introduction you think you need.
The em dash doesn't make your sentence more sophisticated
You're using em dashes to join thoughts that shouldn't be joined. They're not a substitute for structural decisions about how sentences relate.
Draft mode means someone else will publish it
If you're the only person working on your site, draft mode might be hiding a workflow problem you don't actually have.
Write the page title before you write the page
The title isn't decoration you add at the end. It's the constraint that keeps everything else on track.
Write the redirect before you delete the page
Deleting a page without planning the redirect means broken links and lost traffic. Decide where visitors should land before you hit delete.
Search result snippets aren't auto-generated magic
Most CMSs let search engines pick whatever text they want for your result snippet. That's a choice you made by leaving the meta description field empty.
Content audits start with what you can count
You don't need a spreadsheet with forty columns. Start by counting what's actually there, then decide what matters.
Set character limits before users hit them
Field-length constraints aren't validation failures. They're decisions you make visible while someone is still typing.
Write button labels that complete the user's sentence
Button text should finish the thought your interface started. If users have to guess what happens next, your label failed.
Tag taxonomy before you tag a single post
Your CMS will let you create tags on the fly. That doesn't mean you should.
Write error messages before the error happens
You can't write a decent error message in the moment someone breaks something. Draft them during setup, when your head is clear.
Validation messages that tell users what to fix
Error messages that say "invalid format" waste everyone's time. Write validation copy that points to the actual fix.
Decide what happens when users leave a field blank
Every form field on your site needs a plan for what happens when someone skips it. That plan is content work, not a developer problem.
Alt text for people who won't see the image
Write descriptions that work when the image doesn't load, not captions that assume it did.
Empty states are instructions, not decoration
What your CMS shows when a field or section is empty shapes how people use it. Write those moments like documentation.
Batch upload your images once you've named them all
Upload one image, name eight more, upload the next one — you're wasting time on context switching. Name everything first, then upload the set.
Image file names before you upload them
Your image management problem starts when you click 'choose file' with a filename like IMG_3847.jpg. Name it right the first time.
Placeholder text is a prompt, not an example
What you put in empty fields shapes what people type. Most placeholder text just wastes the opportunity.
Write meta descriptions people actually click
Meta descriptions don't affect rankings, but they affect whether your ranked page gets the click. Write them like you're competing for attention, not keyword density.
Revision dates remind you who changed what when
Adding a simple last-updated field to your CMS catches stale content before readers do and gives your team a shared reference point.
Section breaks signal shifts, not just visual rhythm
Readers need structural cues to know when you're changing gears. A section break isn't decoration—it's a visible promise that something new is starting.
Default sort order is an editorial decision
How you order lists, tables, and archives shapes what users think matters. Set defaults deliberately, not by accident.
Mark your required fields before users start typing
Required field indicators work when they appear before the user makes a decision, not after. Visual consistency prevents form abandonment.
Paragraph breaks are structural decisions, not pauses
Most writers treat paragraph breaks like breath marks in sheet music. That's backwards—breaks are load-bearing structure that controls how readers process information.
Write the boring sentence that makes the next one work
Good web writing needs setup sentences that don't dazzle. They hold the door open so the important line can walk through.
Write the list item before you decide it's a list
Formatting content as a list too early obscures whether the items belong together or even need bullets at all.
Footer links are last-resort navigation
If people need your footer to find something critical, your main navigation already failed. Treat footers as cleanup, not strategy.
Version control for content isn't just for developers
Track what changed, when, and why — without learning Git or relying on CMS revision logs that expire.
Write headings before you write the section
Most people write the paragraph first, then add a heading to label it. Reverse the sequence and the work gets easier.
Consistent terminology beats clever synonyms
Using different words for the same thing doesn't improve your writing. It confuses people and breaks their search attempts.
Publish schedules reveal how you actually work
Your editorial calendar isn't aspirational decoration. It's infrastructure that either matches your team's real capacity or creates friction you'll blame on laziness.
Stop writing introductions that repeat the heading
Your first sentence should move the idea forward, not restate what the reader just read in larger type.
File names matter before you upload
Your image file names become part of your site's structure. Name them clearly once instead of renaming them later in the CMS.
Content chunks that actually chunk
Breaking content into sections isn't just visual spacing—it's a structural decision that determines whether your page can be scanned, understood, and used.
Choose your default publish state and stick to it
Your CMS offers draft and published states for a reason. Pick which one new content starts in, make it consistent across your site, and stop creating confusion.
Link text that survives getting skimmed
Most people never read the sentence around your link. Write anchors that work in isolation or stop pretending accessibility matters.
Preview mode is for checking your work, not doing it
If you're writing in preview mode, you're letting visual polish interrupt your thinking. Draft with the CMS tools that keep structure visible.
Your style guide doesn't need a tone section
Most small sites waste time documenting voice when they need usage rules. Write down decisions that prevent inconsistency, not aspirations.
Captions are part of the image decision
If you can't explain why an image is on the page, you probably don't need it. Captions force that honesty.
Sentence length variation isn't a style choice
Monotonous rhythm makes people quit reading. Mix short and long sentences on purpose, not by accident.
Navigation labels are interface copy, not branding
Your navigation isn't a place to be clever. It's wayfinding infrastructure that fails the moment someone has to guess what a link does.
Stop resizing images by eye
Guessing at image dimensions wastes time and produces inconsistent layouts. Define your sizes once, then enforce them at upload or in templates.
Field-level help text that prevents mistakes
Most CMS help text just repeats the field label. Effective help text shows format expectations, gives examples, and stops errors before they happen.
Subheadings that actually subdivide
Most subheadings just restate the topic. Good ones show structure, set expectations, and let scanners jump straight to the part they need.
Draft in plain text, format in the CMS
Separating writing from formatting reduces friction and produces cleaner content. Write first, structure second, style never.
Page titles for people who don't read your nav
A page title needs to work when someone lands there from search, a link, or a bookmark — without any surrounding context. Here's how to write titles that orient people instantly.
Content templates aren't forms to fill in
Templates should guide decisions, not replace them. Here's how to build content templates that actually improve consistency without flattening everything into Mad Libs.
Redirects are documentation your future self will need
Every redirect you set up is a tiny piece of institutional memory. Treat them like the load-bearing infrastructure they are, not cleanup tasks.
The second paragraph is where you lose people
Your intro hooks them, but paragraph two is where readers decide if you're worth their time. Here's what actually keeps them reading.
Breadcrumbs that actually tell users where they are
Most breadcrumb trails break at the worst moment—when users need orientation. Here's how to build navigation that survives real content sprawl.
Edit for the person who arrives at 4pm on Friday
Your reader is tired, distracted, and has six other tabs open. If your page demands their best attention, they'll leave.
Metadata inheritance saves hours you're currently wasting
Stop filling the same fields on every page. Let parent pages pass values down and override only what changes.
Taxonomy before taxonomy: name your buckets once
Most sites drown in overlapping categories because no one sat down first. Define your buckets before you file a single page.
URL structure you can maintain for ten years
Good URL patterns survive redesigns and organizational changes. Plan them with durability, not cleverness.
Alt text audit in fifteen minutes
A systematic sweep through image descriptions that actually helps search and screen readers, without overthinking or AI slop.
One H1 per page is not a rule
The single-H1 myth survives because it used to matter and now it's just cargo cult. Current HTML and search care about hierarchy, not counting.
Build pages people finish
If the reader bounces at paragraph two, the page did not fail at SEO. It failed at being a page.
CMS guardrails for staff who should not design
Editors need power over words and images — not over the gravity of the layout.
Write for scanners without lying
Scannability is not clickbait. It is honest labeling of useful sections.
The editing pass that ships
Stop polishing forever. Use a brutal checklist once, then publish.
Images that earn their kilobytes
A hero image is not decoration. It is either evidence, atmosphere with intent, or dead weight.
Information architecture before voice
Personality is paint. IA is the load-bearing walls. Paint the walls after they stand.