When it comes to creating an XML sitemap, a car analogy works best. Sure, automatic is great. It’s convenient and affords you an extra hand to turn up that Adele song you love to sing along to terribly. But any driving enthusiast will tell you that a manual shift gives you a closer connection to the vehicle and to the road, and that’s exactly what we’re after – more connection. More control.

Related Content:

• Technical SEO Agency
• Ecommerce SEO Agency
• Franchise SEO Agency
• WordPress SEO Services
• Enterprise SEO Services

These days, there are many options for automating the creation of XML sitemaps, whether through a plugin or an online sitemap generator. Some are better than others (the Yoast plugin for WordPress does a pretty good job), but the machines haven’t replaced us just yet. Automation still does not measure up to a carefully-constructed sitemap by hand. So roll up your sleeves and follow these steps to create and submit custom XML sitemaps that represent your site better than any plugin or tool can.

How To Create A Sitemap

Step 1: Know What You’re Looking For

An XML sitemap is essentially just a list of the pages that make up your website. But the key thing to remember is that we are only concerned with pages that should be in Google’s index. You don’t want to put a login page or a post-purchase “thank you” page on your sitemap, for instance. Before you set out to gather up the URLs of the pages on a site, let’s ask a simple question:

“Is this a page that should be in Google’s index?”

 

If you’re a bit more versed in SEO, you can also ask:

“Does the page return a 200 status code?”

and

“Does the page self-canonical?”

 

Doing this exercise will give meaning to everything we encounter in Step 2.

Step 2: Collect Your Sitemap.xml Pages

Now that we know exactly what we’re looking for, let’s go find it! In the first part of this step, we’re going to gather up all of the website’s URLs. The easiest way to do this is with a crawler like Screaming Frog, which can quickly crawl the pages of your site and spit out a list of URLs.

Alternatively, you can simply follow each of the site’s main navigation options down to their deepest level (also known as a human crawl). This is actually the method I prefer. If the site isn’t too big, it’s a great way to learn about the navigational logic and user-friendliness of your site.

Let’s use Go Fish Digital’s site as an example. Before I toss it into a crawler, I’m going to browse it manually and gain some insights. My first takeaway, as is often the case, is from the main navigation.

On the far left, we have a logo and branding, which links to the home page. You guessed it – the home page URL is going in the sitemap.

On the right, we have About, Services, Blog, and Contact.

Right away, I’m going to begin grouping. The About and Contact pages are more general pages, like the home page, so I consider those three URLs as a “General” section of the site.

General pages

https://gofishdigital.com/

https://gofishdigital.com/about-us/

https://gofishdigital.com/contact-us/

Next, we have Services and Blog.

Services has a drop-down menu – this is a perfect reason to group these pages together!

Service Pages

https://gofishdigital.com/services/

https://gofishdigital.com/search-engine-optimization/

https://gofishdigital.com/online-reputation-management/

https://gofishdigital.com/website-design-and-development/

https://gofishdigital.com/content-marketing/

https://gofishdigital.com/search-engine-marketing/

https://gofishdigital.com/conversion-rate-optimization/

Then, the blog. I’ve only displayed 3 posts here, but there are a lot more blog posts on GFD’s site. This is where a crawler would come into play.

Blog posts

https://gofishdigital.com/blog/

https://gofishdigital.com/google-shows-us-context-is-king/

https://gofishdigital.com/mobile-geofences/

https://gofishdigital.com/google-searching-tv/

Would you look at that? We now have the site sectioned out nicely. With our URLs grouped together like this, we can make a beautifully-organized sitemap!

In the last part of this step, we’re going to take out any pages that don’t hold up to the question(s) we asked in Step 1. I did find a privacy policy page in the footer, and I’ve decided not to include it. It’s not a keyword-focused page that is going to perform well in search. Never forget that you can include or exclude whatever pages you want when creating a sitemap!

https://gofishdigital.com/privacy-policy/

Step 3: Code Your URLs For Your Sitemap.xml

If you’ve applied Step 2 carefully to your website’s pages, you now have a list of URLs that need to be formatted with the appropriate tags. XML is a lot like HTML – in fact, the “ML” in both stands for “markup language.”

For this step, you’ll need a text editor so you can create an XML file. I highly recommend Sublime Text. They offer a lifetime license key, and it will serve your SEO and text-editing future better than the finest hound.

a.) Let’s begin with an opening <urlset> tag:

<urlset https://www.sitemaps.org/schemas/sitemap/0.9″>https://www.sitemaps.org/schemas/sitemap/0.9“>

b.) Next, add your first URL with the appropriate <url> and <loc> tags:

<url>

<loc>https://gofishdigital.com</loc>

</url>

c.) When you’ve entered your last URL, simply close the <urlset> tag:

</urlset>

Now that you know the different tags, get your eyes used to looking at a simple XML sitemap. Here is what the finished product would look like:

Step 4: Validate Your Sitemap.xml

*Please note that the validation method below does not seem to be working consistently anymore. I am seeing perfectly valid sitemaps that are validating in Google Search Console fail the validation test below. As of November 25, 2019, the best method for validating your XML sitemap is to submit it within the Google Search Console account for your specific website.

Now it’s time to run your sitemap through a validator to make sure all the syntax is correct. Go ahead and save your file and name it sitemap.xml. Then, visit https://validator.w3.org/#validate_by_upload and upload your XML file. Hopefully, you see this message:

If there are any errors, the validator will quote the line that contains the error so you can go back into Sublime Text and easily locate it.

Step 5: Add It To The Root

Next, you’ll want to add your sitemap file (sitemap.xml) to the root folder of your site. This can be done locally, through FTP or (ideally) by a developer. Adding your sitemap file to the root folder means that it will be located at yoursite.com/sitemap.xml. This is true for a lot of sites! Trying picking a couple of sites you regularly visit and type “/sitemap.xml” after the TLD (the “.com,” “.net,” etc.).

ex: https://www.apple.com/sitemap.xml

Step 6: Add Your Sitemap To The Robots(.txt)

A robots.txt file is a simple text file with instructions for the crawler that is visiting your site. The file exists in the root folder, so you can probably guess where it’s located – yoursite.com/robots.txt. One of the lines you can add to your robots.txt file is the “Sitemap:” line. This will ensure that the crawler goes and checks out your perdy, custom XML sitemap. Here’s how the the line would look, assuming your site is secure (HTTPS):

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

Apple.com has a number of “Sitemap:” lines in their robots.txt file (https://www.apple.com/robots.txt):

Adding a line to your robots.txt file that points to your sitemap is somewhat debated as effective, but the purpose of this guide is to be thorough, and it is still a best practice I see utilized by many top SEOs and successful websites.

Step 7: Submit Your Sitemap

We gathered, we grouped, we tagged, we validated, and we added to the root. Now we’ll discuss how to submit your sitemap to Google and Bing. Doing so can improve the indexation of your site! Please note that I’m assuming you have Google Search Console and Bing Webmaster Tools accounts set up.

How to submit a sitemap to Google

a.) Sign into your GSC account.

b.) Click Crawl > Sitemaps > Add/Test Sitemap

c.) Enter “/sitemap.xml” into the available field and submit your sitemap!

How to submit a sitemap to Bing

a.) Sign into your BWT account.

b.) Click Configure My Site > Sitemaps

c.) Enter the full URL of your sitemap and submit your sitemap!

Check in periodically (but not obsessively) to ensure your sitemap URLs are being crawled. It is NOT uncommon for only part of your sitemap to be crawled. In fact, we rarely see a sitemap crawled in its entirety. That’s asking a lot and the major search engines love to be coy.

(Bonus) Next-Level Sitemapping: Creating an Index

The whole point of a sitemap is to make the pages of your site as crawler-accessible as possible. To do this, we present them in a simple, organized list. If you want to take order to the next level, you’ll want to create a sitemap index.

A sitemap index is an XML file that refers to a number of individual XML sitemaps. For Go Fish Digital’s site, we could make an individual sitemap for each grouping we created in Step 2:

general_sitemap.xml

services_sitemap.xml

blog_sitemap.xml

We would add each of these files to the root folder of the site and point to them within a sitemap index, which uses its own XML tags:

We would then name the sitemap index, validate, add it to the root folder, and submit it within the search engine consoles for Google and Bing – no need to submit each individual sitemap! The index will take care of everything. Additionally, you can add a “Sitemap:” line to your robots.txt file that points to the index, rather than pointing to each individual sitemap (looking at you, Apple).

A sitemap index with individual sitemaps represents the highest level of organization and is a superb way to present the indexable pages of your site to the major search engines.

Create Your Sitemaps!

Whether you’re looking at your own site, a friend’s site, or a client’s site, you now have some great guidelines for creating a meaningful XML sitemap or sitemap index. So build your own custom sitemap and take charge of your SEO, learn more about your website, and cut the fat caused by automation.

Happy mapping!

Follow me on Twitter @briangormanGFD

How To Create & Submit A Sitemap: The Definitive Guide is an original blog post first published on Go Fish Digital.

Training your employees is an essential part of developing a skilled and motivated workforce. Whether you’re a small business owner or a manager at a large organization, investing in employee training can have a significant impact on the success of your business.

Related Content:

• Online Reputation Management
• Digital PR Services
• Content Marketing Agency
• Custom Website Development Services

In this blog post, I’ll share 10 tips for training employees that I’ve developed after years as a classroom teacher as well as training employees at the manager, director, and VP level. These items apply to any lesson or presentation you plan to administer, whatever your particular training program might be.

Some of the benefits of a well-trained staff include:

• Increased productivity / output
• Improved deliverables / client retention
• Increased innovation
• Reduced turnover

It’s one of the best investments you can make, and this list will help you get the most out of your team and build the next generation of all-stars.

10 Tips for Effectively Training Employees

1. Start with the outcome: Define what you want the employee to understand and/or be able to do at the end of the training session.
2. Keep it relevant: Ensure that everything you cover in the training is relevant to the desired outcomes.
3. Use empathy: Consider the training from the perspective of the attendees and how they will receive the information.
4. Make it impossible to fail: Structure your training in such a way that it’s impossible for your student to fail.
5. Use visuals: Incorporate visuals into your training to make it more engaging and memorable.
6. Let them drive: Make your training interactive and give attendees the opportunity to participate actively.
7. Say less: Be concise in your explanations and avoid over-explaining or covering too much material in one sitting.
8. Assign a follow-up exercise: Give attendees a task to complete after the lesson to help cement the concepts and allow them to apply what they’ve learned.
9. Plan a review: Schedule a review of the material to reinforce learning and aid long-term retention.
10. Measure effectiveness: Assess the effectiveness of your training to provide targeted feedback and ensure that it’s enhancing the attendees’ skills and understanding.

At the end of this training session, what do you want the employee to understand and/or be able to do? Here, it’s important to be realistic – give yourself a reasonable target and then write out the path to hitting the bullseye.

I’ve failed at this by trying to cover too much in one training session.

I solved it by going for 1-3 desired outcomes for each session. For example, one concept and one tactic within a tool makes for a great, easily digestible 30-minute lesson.

Once you’ve chosen your outcomes, make sure everything you cover is relevant to those outcomes.

I’ve failed at this by going too far off topic and meandering into territory that wasn’t as useful to the lesson.

I solved it by first determining what information is foundational to the lesson. Then, I map concepts that reach further out. Anything that isn’t critical – that would require too much explanation – is removed. This is typically more suitable for a separate session.

We often plan a training “in one direction,” which means we only think about what we want to teach the attendees. That’s great – it shows you care – but it’s very important to take a moment to perceive things from their seat and consider how the training will be received.

I’ve failed at this by forgetting to cross-check each part of my lesson with the question “how will the person receive this?”

I solved it by ensuring, to the best of my ability, that each part is:

• engaging or
• enjoyable or
• interactive or
• appropriately challenging or
• all of the above

This may be the single most important tip in this post.

I love jiu jitsu, and long ago I found this video that contains, among others, one of the most useful lessons on teaching I have ever encountered – make it impossible for your student to fail.

The first half of the video is critical, the second half contains an interesting story. If you want to improve as a teacher, I implore you to watch at least the first part!

I’ve failed at this by prioritizing detail over clarity, and forgetting to ask “is there any opportunity for the employee to fail?”

I solved it by eliminating, as much as possible, the failure points within my lessons, through things like clearer explanations and in-lesson assessments / checkpoints to ensure we’re getting the desired outcome.

Visuals can be fun, impactful, and supportive. Any time I can make a lesson or presentation more visual, I do it. For certain learners, it can be crucial.

I’ve failed at this by missing opportunities to use effective visuals that could have enhanced a lesson. I’ve even committed the dreaded “slide filled with text that I read to the audience” sin.

I solved it by making lessons more visual, and asking “what are 1-3 images the audience will remember when the lesson is over?” Using memorable images can help participants better recall what they’ve learned.

Any chance you have to make a lesson more interactive, take it! You could take 100 cooking classes but if you only ever watch, you’ll never learn to cook.

I’ve failed at this by getting too focused on presenting all the right information and forgetting to give my subjects a chance to “do.”

I solved it by asking, at various points in lesson planning, “is there a chance to pause here and allow the subject to do an exercise?” Sometimes, I teach first and let them try. Other times, I let them drive while I explain and then recap when we’re done.

In teaching, saying less often allows for more: it creates space for subjects to engage, question, and explore ideas themselves, fostering a deeper, more personal understanding of the material. I’ve also found that there is far more recall if I trim down the word count.

I’ve failed at this by being too detailed, over-explaining, and covering too much material in one sitting.

I solved it by being very deliberate about explaining things in the fewest words possible, and by saying things only once (avoiding circling back to say something again).

Assigning a task after a lesson helps cement the concepts, gives students a chance to apply what they’ve learned, and lets us gauge how well the material has been understood.

I’ve failed at this by missing the opportunity to assign an immediate follow-up exercise after a lesson.

I solved it by doing so more regularly and making this a part of my lesson plan template.

I’ve failed at this by creating long-term lesson plans that go on without end, continuously covering new material.

I solved it by baking in reviews of previously-learned material using spaced repetition.

I’ve failed at this by not identifying relevant ways to measure how effective trainings have been.

I solved it by spotting opportunities within the training program where an assessment can be made (i.e., reviews) as well as thinking about the desired outcomes of the training program as a whole (beyond just the grasp of each lesson subject).

The Final Word on Training Employees

These ten tips provide a roadmap to create engaging and impactful employee training sessions that boost individual performance and fuel overall business growth.

The art of successful training hinges on pinpointing desired outcomes, fostering empathy, orchestrating interactive lessons, and continuously measuring progress. Embrace these strategies to unlock the full potential of your team, and invest in their skills as the ultimate asset for your organization.

How to Train Employees – 10 Important Steps is an original blog post first published on Go Fish Digital.

Related Content:

• Technical SEO Agency
• Ecommerce SEO Agency
• Google Analytics 4 Agency
• Conversion Rate Optimization Services

The problem is that you want to apply Article schema to your news blog posts, but you have 1,000 of them. Crack those knuckles and fire up a Spotify playlist, because you’re going to be writing a lot of code.

The solution is to add schema to any number of pages with just one piece of dynamic code.

This guide will show you how to:

• Create a schema code template
• Insert variables into that template
• Replace those variables with information from the page
• Add the schema code to any number of pages using Google Tag Manager

Let’s get started!

Step 1: Pick a Page Type

While this works for any page type, it makes more sense to choose a type that is represented by more than one page. Here are some page types this can work well on:

• Blog posts
• News articles
• Job postings
• Local pages
• Product pages

For this lesson, we’ll use a blog post:

A Guide To Structured Data For SEO

(And if you’re looking to learn more about schema / structured data, that’s a great post to read).

Step 2: Create the Schema Code Template

I’ll use Merkle’s Schema Generator to create templated code that works well for our purposes. I chose the Article type, and here is what it generated:

Step 3: Turn Values into Variable Names

Replace each empty value with a variable name. Choose the most logical variable names possible. Put variables inside double curly braces (this is how Google Tag Manager recognizes something as a variable).

Notice how most of my variable names have underscores, but one does not:

This is foreshadowing a bit, but – Google Tag Manager has some built-in variables, and they are already named. “Page URL” is one of them – this is the variable in the code above that does not have an underscore.

The rest of the variables in the code will be user-defined (meaning I’ll create them), and I like to use underscores to differentiate my own variables from those that are already built into GTM. It’s a preference, but I do recommend doing this.

Step 4: Create the Variables

4a. The GTM method

Create the variables that will insert information into our schema code. Go to GTM > Variables:

{{Page URL}}

The first variable in our code, {{Page URL}}, is built into GTM:

The page URL, in this case the address of the blog post, will be inserted into our code. Pretty nice!

{{Blog_Heading}}

The next variable is {{Blog_Heading}}, and we’ll have to build that one. Scroll down to “User-Defined Variables” and click “New.”

Name this variable “Blog_Heading.” Next, choose “DOM Element” as the variable type. You’ll do this for all subsequent variables.

Then, help GTM find the page information we’re looking for. This is the trickiest part to understand, so take your time with this part and be open to researching anything that doesn’t make sense (Google and/or ChatGPT are good options for this).

The title of the blog post I’m attempting to create schema code for is “A Guide To Structured Data For SEO.” Looking at the code, I can see that the blog title is an h1 HTML tag with a CSS class of “blog-title.”

I can find the title of the blog using the HTML tag:

• h1

And the CSS class:

• .blog-title
• (CSS classes are “called” with a period character)

Combine the two to make a very specific selector:

• h1.blog-title

Go Fish codes all of their blog titles like this – they are wrapped in an h1 tag, and they use the “blog-title” CSS class. It’s very important that we choose a selector that will work on all blog posts. The more organized a site’s code is, the more possibilities it opens up, and this is a perfect example of that. This will make it really easy to find blog headings and insert them into our schema code. Speaking of finding the blog heading, let’s finish building this variable in GTM:

The combination of HTML tag reference and CSS class reference is called a “CSS Selector.” It’s almost like a breadcrumb trail that leads to the information you’re looking for. It might not always work this cleanly, but we’ll try to reference like this each time, and when it fails, we’ll look for another way. Here are some additional tips when finding a reference to the information for your variable:

• Be as specific as possible. We could have referenced this information with just the CSS class, “.blog-title,” but I had the option of being more specific and including the h1 reference, so I went with that.
• Search the DOM using your selector to be sure it’s the only instance found in the code. Search it on a sample set of pages to be sure things are coded consistently.

{{Image_URL}}

Our next variable is {{Image_URL}}. This is the featured image of the blog post. We need somewhere in the code that references this image consistently across all blog posts. The OG Image is perfect for this – it’s what Facebook uses, and the image URL will always be found in a particular meta HTML tag in the code of our blog posts:

We’ve already run into a case where we’ll have to change how we reference the information we’re looking for. We’ve got the HTML tag (“meta”), but there’s no CSS class. First, we’ll identify the specific meta tag we’re looking for:

• meta[property=”og:image”]

Then, we’ll help GTM find the image URL by naming the “content” attribute within the meta tag. Here’s how that will look:

{{Author_Name}}

Use Chrome to inspect the author’s name and show the following code:

Select the author’s name with:

• span.author > a

This is similar to the first technique we used, HTML tag + CSS class. But the path to this information includes one additional HTML tag, so we continue the path with “>” and then state the tag (“a”). Search the code to confirm your selector is finding the right information:

{{Publish_Date}}

• div.info > p

All variables are created, and GTM is able to find the information we’d like inserted into our code dynamically.

Step 5: Create a Script

Some Javascript is needed to get things working right. The code is wrapped in HTML “script” tags, and you’ll see our schema code dropped right in the middle of the JS. You can use this script for any code template you create, just insert your code in place of mine.

It’s good to know what the JS is doing here:

• var schema= creates a variable called “schema” that will hold the JSON-LD data.
• var script=document.createElement(‘script’); creates a new script HTML tag.
• script.type=”application/ld+json”; indicates that the script contains JSON-LD data.
• script.innerHTML=JSON.stringify(schema); turns the schema code into a string (letters, numbers, punctuation, etc.) and puts it inside the script tags.
• document.getElementsByTagName(‘head’)[0].appendChild(script); puts the entire script into the <head> of the page as a child element.

Step 6: Create a Google Tag Manager Tag

Click “Tags.” Choose “Custom HTML” as the tag type, and paste the script in.

Step 7: Create a Google Tag Manager Trigger

As you’re creating the tag, you should see the option to create a trigger just below. This is where we’ll tell GTM to insert our dynamic code into every instance of our chosen page type.

Choose “Page View” as the trigger type. The trigger will fire on “Some Page Views.” The trigger will fire when the Page Path contains “/blog/” (in this case).

Save the trigger and the tag.

Step 8: Test the Staging Implementation

Click “Preview” in the upper right. Enter the a URL you’d like to test and click “Connect.”

Confirm that Tag Assistant has connected.

Choose the first instance of “Container Loaded” and confirm that your tag has fired.

Click into the fired tag to confirm your trigger is working as intended.

Return to the previous screen and click “Variables” (with “Container Loaded” selected) to confirm your variables are working as intended.

Check the DOM of the page you’re previewing (you’ll see “?gtm_debug=” in the URL). I can see our inserted script, the schema template, and the correct information inserted via our variables.

These are some checks you can do to ensure everything is working correctly. Test a sample set of pages to confirm further.

Step 9: Test the Live Implementation

Now it’s time to push the tag live! Click the blue “Submit” button in GTM, next to the “Preview” button.

With the changes live, and as done in the previous step, check the DOM of a sample set of pages to ensure the code is being inserted and inserted correctly. Then, run it through a tool like https://validator.schema.org/. Once again, you’ll want to check a number of pages.

And that’s it! In this exercise, we:

• Created a schema code template
• Inserted variables into that template
• Replaced those variables with information from the page
• Added the schema code to all blog posts using Google Tag Manager

Bonus (JS Variables)

We can do the same thing using JS to build our variables. The reason I like this method so much is that it’s a little more flexible for selecting elements. I’ve hit limitations using the method above that I was able to get around by using JS variables rather than building them in GTM (admittedly, could be user error).

Let’s look at the anatomy of creating a variable and selector using JS:

Full example: var blogHeading = document.querySelector(‘h1.blog-title’).innerText;

• var blogHeading sets our first variable as “blogHeading.” I chose a different (and more Javascripty) naming convention to avoid confusing variables with those written above.
• document.querySelector(‘h1.blog-title’) searches the document for an h1 tag with a class of “blog-title.”
• innerText selects the text found within our selector.

The JS syntax is pretty logical once you get used to it, and the selection method closely mirrors what we did earlier. Here are all of my variables and selectors for this example:

• var pageURL = document.querySelector(‘meta[property=”og:url”]’).getAttribute(‘content’);
• var blogHeading = document.querySelector(‘h1.blog-title’).innerText;
• var imageURL = document.querySelector(‘meta[property=”og:image”]’).getAttribute(‘content’);
• var authorName = document.querySelector(‘span.author > a’).innerText;
• var publishDate = document.querySelector(‘div.info > p’).innerText;

Check to make sure these are selecting the right information. Open Chrome Inspector, select “Console,” and enter a selector (without the variable statement):

Everything appears to be pulling the correct information. On to the schema code template:

Tips

If you do run into a tricky scenario regarding your selectors (i.e., nothing you try will select exactly what you’re after), try selecting the element, right-clicking in the DOM, and copying the selector. Some selector paths will be long, but it’ll work.

Additionally, if you’re not getting the desired output from your selector using “innerText,” you can also try “innerHTML” or “textContent.”

Testing Steps

• Create a custom HTML tag in GTM and paste this code in.
• Create a trigger that fires on all desired page types.
• Select “Preview” and inspect the DOM to ensure the code is present and correct.
• Submit the tag and check the live page.

Conclusion

Remember that you can do this for almost any page type on your site. With these methods, you’ll apply schema to your existing pages, and GTM will automatically insert the code on to future pages as well. Give it a try and let me know how it works!

Credit to Anoop T Unnikrishnan for his post on this topic that inspired us to write our own about it!

How to Create Dynamic Schema With Google Tag Manager is an original blog post first published on Go Fish Digital.

What I’ve Learned About Content

I remember my early days of writing and editing content. Obsessing over keyword placement in title tags, headings, and paragraphs. Using all kinds of tools to come up with secondary and semantically-related terms. The deeper I got into the process, the more unnatural it felt. But once I had the opportunity to take part in an SEO audit for a major news outlet, my outlook on content creation changed dramatically.

Related Content:

• SaaS SEO Agency
• Technical SEO Agency
• Ecommerce SEO Agency
• Shopify SEO Services

Reviewing their webpages was an enlightening experience. Their content, especially in the eyes of an SEO analyst, was something to behold. It had enticing title tags, appropriate heading structure, and robustly informative content that exhausted every angle and made mention of the article’s direct subject and all related entities. These pages were a truly great resource for search engines to deliver, and something that would not only keep users on the page for extended periods of time but would also build trust that this news outlet was the only source they’d need for information on a story.

Now let’s be clear on something – some big reasons this content ranked so well was due to the long history of the website, the deep brand development, and a very strong backlink profile. But there is no denying that these articles were superb and a model for sending powerful ranking signals.

The epiphany happened for me when it came to breaking news stories. To optimize for these stories, the news outlet used Google Trends, but it wasn’t possible to do keyword research in the traditional sense. I know what you’re thinking – optimizing a web page without doing keyword research? Blasphemy! But when I thought about it, it made perfect sense.

There is a stiffness to the process when we are beholden to a single primary keyword and a suite of third-party tools, constrained by the motivation to work things in and smartly place words and phrases. I believe that, more often than not, our content output suffers for it. We get too focused on the SEO goals we have for the page, rather than being focused on the content. We try to be clever instead of trying to be informative. Look at the top-ranking results for a wide array of queries. Experienced SEOs will know what I’m talking about when I say there is a “comfort” to good content; a freedom and ease to the writing, rather than having obvious SEO elements planted all over the place. I’d like to do better in 2018 and beyond, and I believe I know how.

Pick a topic, gather as much information as you can, clearly state what you’re writing about in your title tag and main heading, and then write. Whether you’re writing metadata or body content, avoid the contamination of doing keyword research as the first step and just write.

To Improve Your Content, Stop Writing It

But let’s back up. Before I share what I feel is a better process for writing content that can improve the SEO performance of your website’s pages, let’s get right to the big reveal: how can you improve your content without writing it?

That’s right – speak it.

Whether you’re writing from scratch or updating something that already exists, I recommend using voice-to-copy software on your computer or phone to produce it. There are steps you must complete before doing so, which I’ll outline below, but this is a technique no one is talking about that could be a game changer in terms of the quality of content you produce for your own site or for your clients. And if you’re an SEO tasked with writing content (which many of us are), let’s not sleep on the time you could save with this method.

The specific tool I use is the dictation option that can be found under Google Chrome’s edit menu (note: I’m on a Mac):

Another option I use frequently is the “Memo” app on my Android phone. I find the phone’s voice-to-copy to be more accurate than the browser option. When I’m finished dictating, I just email the draft to myself.

This will take some practice. It will feel awkward at first. You’ll spend a lot of time saying partial sentences, stopping, and then starting over again. But you’ll get better at it quickly, and you’ll soon find that your word counts will increase with less time spent and your content will have a natural flow to it that you weren’t seeing before. It will be more readable and easily digestible because it has a more conversational feel. It will “speak” to readers like content riddled with sections of SEO chess moves never will.

How To Write New Content

• Choose a topic – This can be a news story, a product if it’s for e-commerce or a service-based site, etc. It’s simply what the page you’re creating will be about.
• Ask questions – Write down every question you have on the topic.
• Research – Don’t skip leg day. There is sometimes a reward for laziness, but it is always temporary. Read everything you can on the topic, and compile notes. If certain things keep getting mentioned, write them down. Then, read your notes.
• Ask more questions – Now that you’ve researched, try to think of questions you didn’t think to ask in step 2. What would people who had no knowledge on the topic wonder? Search for an FAQ list on your topic for more ideas.
• Create – You can either verbally answer all of the questions you’ve come up with, or simply speak on the topic as if it were a presentation. Hit that record button and go!
• Review and organize – Make edits as you see fit. Not everything you said will be perfect, but you’ll have a terrific foundation that you can now make small adjustments to. Read through everything, move sections around, and make sure it’s all well organized. Above all else, make darn sure the page is as informative as it can possibly be. Pro tip: make the questions above part of your content!
• Metadata and headings – I like to create and read my content before creating a title tag, meta description, and heading/subheading for it. That way, I can see how it came out, what it’s really saying, and give it appropriate metadata and headings.
• Perform KW research – Now is the time to ask, “are there some language adjustments that can be made to the content to help more people find it?” Take your primary topic, do keyword research, and make the appropriate adjustments. Don’t let this step get away from you – season to taste. You’ve chosen a topic and have thoroughly “written” on it – the search engines will see that.

How To Update Existing Content

When you’re looking to update content that already exists, the biggest difference is that you’ll be identifying a topic for the page rather than choosing one. Another difference is that we’ll be working with and working around content that is already there.

• Identify the topic – Answer “what is this page about?” by reading the entire page.
• Ask questions – Write down every question you have on the topic.
• Research – It’s leg day again.
• Ask more questions – Think of questions you didn’t think to ask in step 2. What would people who had no knowledge on the topic wonder?
• Create – Hit that record button and go!
• Review and organize – Make edits as you see fit. Since we’re working with existing content, some sections may need to be adjusted, moved, or taken out (if they meander off topic, for instance).
• Metadata and headings – Give the content appropriate metadata and headings.
• Perform KW research – Season to taste.

If the page already has some good content and merely needs some fine tuning, just perform the last step from the list above (“season to taste”).

I believe that this approach is, at best, a superior way of producing content that performs well, and, at least, another tool in your arsenal. For SEOs, I urge you to adopt this methodology. We’re responsible for becoming experts on the subject matter of our clients and producing better resources for users, and for me, this has been the single most effective way of doing just that.

Please share your thoughts on this post in the comments! If you give this approach to content creation a try, come back and let me know your experience with it and the results you saw. As for me, I’m going to go back and edit out all the throat clears that occurred during the making of this post.

Thank you for reading!

Want Better SEO? Stop Writing Content. is an original blog post first published on Go Fish Digital.