Forem: Juha

pSEO - Programmatic SEO Quick Intro with Examples

Juha — Fri, 07 Jun 2024 09:00:57 +0000

TLDR: pSEO automates the creation of web pages at scale for specific keywords. It's useful for businesses targeting various locations or services. For example:

Tyre shops in <city>
Stock price of <company>
Alternatives to <product>

It's a powerful tool, but there are risks. If done carelessly you can be flagged as spam.

What is Programmatic SEO and Do I Need It?

Programmatic SEO (pSEO) is a strategic approach that involves the automatic or semi-automatic generation of web pages to target specific keywords relevant to your business.

This technique leverages data and automation to create numerous pages that are optimized for search engines, thus enhancing the chances of appearing in search results for a broad range of keywords.

For example, you might have seen websites with individual pages for all cities:

barber shops barcelona
barber shops madrid
barber shops <city_name>
etc.

The page template is identical between the hundreds of city pages, but dynamic parts have been programmed into them. That means parts of the pages change between cities but for the most part they are identical copies.

So what's it good for and do you need it?

Why You Might Need Programmatic SEO:

Scalability: If your business covers a wide range of topics or products, manually creating pages for each keyword can be time-consuming and inefficient. pSEO allows for scalable content creation.
Efficiency: Automation reduces the workload on your content creation team, freeing them up to focus on more strategic tasks.
Competitive Edge: By covering more keywords, you can stay ahead of competitors who rely solely on manual SEO efforts.

How Does Programmatic SEO Get You More Visitors?

Programmatic SEO boosts visitor numbers by systematically targeting a multitude of high-volume keywords. This is achieved through:

1. Broad Keyword Coverage:
pSEO enables you to cover a wide range of keywords that might be overlooked in manual processes. Each automatically generated page targets a specific keyword, e.g. all major cities relevant to your business.

For example you can use pSEO to create individual city pages:

tyre shops helsinki (/tyre-shops/helsinki)
tyre shops stockholm (/tyre-shops/stockholm)
tyre shops oslo (/tyre-shops/oslo)
etc.

This increases the likelihood of appearing in search results, as users are typically interested in city specific results.

2. Efficient Use of Resources:
With pSEO, you can create thousands of pages in the time it would take to manually produce a handful. This efficiency translates to a more comprehensive online presence.

3. Data-Driven Content:
By utilizing structured data, pSEO can help you fill each page with relevant and valuable information, enhancing user experience and boosting search engine rankings.

Of course there are risks of appearing spammy if pSEO isn't done thoughtfully.

Example of a website heavily using pSEO

Dictionaries and synonym databases are a type of website that understandably rely almost entirely on programmatic SEO.

As their content is in an easily accessible format in a database, it can be pulled to create pages for each word.

As an example take a look at anotherwordfor.xyz which utilizes pSEO to generate pages like:

In addition to this, they also have manual SEO pages like:

Perfect adjectives to describe a person

If you look closely, you might identify parts even on manually created SEO pages that can be semi-automated. Have a look at the adjective lists on the above page.

How to Get Started with Programmatic SEO?

1. Keyword Research:
Identify high-volume, low-difficulty keywords relevant to your business. Tools like Ahrefs and SEMrush can help pinpoint these keywords.

2. Data Collection (super important!):
Gather data that can be used to populate your programmatically generated pages. This could include product details, reviews, user-generated content, or other structured data relevant to your industry.

3. Template Creation:
Develop templates for your pages that can dynamically incorporate your collected data. Ensure these templates are SEO-friendly and provide a good user experience.

4. Automation Tools:
Use automation tools and platforms to generate the pages. Examples include Python scripts, pSEO plugins, or custom solutions tailored to your needs.

Where to Find Keywords for Programmatic SEO?

1. Keyword Research Tools:
Utilize tools like Ahrefs and SEMrush to discover keywords with high search volume and low competition. These tools also offer insights into related keywords and search trends.

2. Google Autofill and Search Suggestions:
Google’s search bar suggestions and related searches at the bottom of search results pages are excellent sources for identifying commonly searched keywords.

3. Competitor Analysis:
Analyze the keywords your competitors are targeting. Tools like SEMrush and Ahrefs can provide detailed reports on competitor keywords, helping you identify gaps and opportunities.

4. SERP Analysis:
Review the search engine results pages (SERPs) for your target keywords to understand the type of content that ranks well. This can guide your content creation strategy.

How Much Does Programmatic SEO Increase Visitor Count?

Programmatic SEO can significantly increase visitor count by allowing your site to appear in search results for a vast number of keywords. The key benefits include:

1. Enhanced Visibility:
More pages targeting relevant keywords mean more opportunities for users to find your site.

2. Increased Traffic:
With more targeted keywords, you attract a broader audience, which can lead to higher traffic volumes.

3. Better User Engagement:
By providing content that meets user needs and search intent, you can improve engagement metrics, such as time on site and pages per visit, which further boosts SEO performance.

4. Measurable Results:
Track the performance of your programmatically generated pages using analytics tools to refine and optimize your strategy continuously.

What Drawbacks Does Programmatic SEO Have?

While powerful, programmatic SEO comes with potential drawbacks that need careful consideration:

1. Risk of Low-Quality Content:
Automated content can sometimes lack the depth and quality of manually created content. It’s essential to ensure that the generated pages provide value to users.

2. Potential for Penalties:
If programmatic SEO is done in a spammy or manipulative way, it can lead to penalties from Google. Ensure your practices adhere to Google’s guidelines and focus on user experience.

3. Over-Reliance on Automation:
While automation is beneficial, relying solely on programmatic SEO can neglect the nuanced and creative aspects of content creation. A balanced approach, combining both manual and automated efforts, is often the most effective.

By understanding and addressing these potential pitfalls, marketers and entrepreneurs can effectively leverage programmatic SEO to enhance their online presence and drive more traffic to their websites.

Convert your WordPress site to static HTML with wget

Juha — Wed, 29 Nov 2023 07:37:08 +0000

This technique not only accelerates load times but also strengthens site security.

The downside? You'll sacrifice the dynamic content management capabilities of WordPress, along with features like interactive feedback forms and built-in search functionality.

Perfect for making a browsable copy of your website content.

In this quick guide, we'll explore the practical steps to seamlessly transform your WordPress site into an optimized, static HTML using tools like wget. Perfect for developers and tech-savvy individuals, this guide will help you streamline your web presence with a focus on performance and security.

Let's get started on converting your dynamic WordPress site to static HTML.

The pros and cons of converting WordPress to static HTML

The pros 👍

Speed: Static HTML pages load faster as they don't require server-side processing.
Security: Reduced vulnerability to hacking and malware, as there's no database or PHP to exploit.
Simplicity: Easier to maintain with fewer moving parts.
Hosting Price: Can be hosted on any server, including inexpensive or free hosting services.
Scalability: Better handles high traffic without requiring complex caching or database optimizations.
Dependability: Less downtime since there are fewer components that could fail.

The cons 😯

Loss of Dynamic Features: No real-time content updates, comments, or search capabilities inherent to WordPress.
Manual Content Management: Content updates require manual HTML editing.
Limited Interactivity: No built-in support for interactive elements like forms unless integrated with external services.

If you know what you're getting into keep reading! 🤩

Download your WordPress with wget

wget \
--mirror \
--convert-links \
--adjust-extension \
--page-requisites \
--no-parent \
--no-clobber \
--wait=0.5 \
--reject-regex=".*/(\?p=|wp-json|feed|xmlrpc).*" \
--domains=example.com \
https://www.example.com

--mirror: Enables options suitable for mirroring websites, like infinite recursion depth.
--convert-links: After downloading, converts the links in the documents for local viewing.
--adjust-extension: Adjusts the extensions of the downloaded files (like adding .html to text/html or .css to text/css).
--page-requisites: Downloads all the elements required to properly display a page (images, CSS, etc.).
--no-parent: Ensures that links to the parent directory are not followed.
--no-clobber: Prevents downloading the same files multiple times.
--wait=0.5: Waits 0.5 seconds between server requests.
--reject-regex=".*/(\?p=|wp-json|feed|xmlrpc).*": Don't download URLs matching the specified regular expression pattern.
--domains=example.com: Don't wander off to other websites via external hyperlinks. Restricts the download to the specified domain.

Tweak hyperlinks in your newly created static HTML documents

Want to browse offline? Skip this step.

This step removes index.html from all hyperlinks. Go through with it only if you're going to run the site in a web server, e.g. Nginx or Apache.

find . -name "*.html" -exec sed -i 's|/index.html"|/"|g' {} +

Find all .html files and execute a search and replace on their contents. E.g. <a href="/my-article/index.html"> → <a href="/my-article/">

Conclusion: Your Journey to a Static HTML Site

You've successfully transformed your WordPress site into a static HTML version, unlocking faster load times and enhanced security. While some dynamic features of WordPress are now absent, the benefits in performance and maintenance simplicity are substantial.

How to import node-persist into a Node.js ES6 project

Juha — Tue, 14 Nov 2023 17:57:11 +0000

Working on a Node.js project with ES6 syntax can sometimes present challenges, especially when incorporating modules like node-persist that aren't natively aligned with the ES6 import style.

Fortunately, there's a workaround to use CommonJS modules within ES6 scripts, and here's how you can apply it to node-persist.

const nodePersist = await import('node-persist');

const storage = nodePersist.default.create();
await storage.init({ dir: 'my-path' });

const foo = await storage.getItem('foobar');

Key Takeaways:

Dynamic import() function: This approach utilizes the dynamic import() function, which is essential for loading CommonJS modules in an ES6 environment.
The default property: After importing, it's crucial to access the default property. This is where the module's main functionality resides. Hence, nodePersist.default.create() is used to create a new instance.

Understanding the differences is key: CommonJS modules (require()) represent the traditional standard in Node.js, while ES6 modules (import) offer a more modern approach.

Bridging these two with dynamic import ensures that your project can leverage the best of both worlds.

Sending Email with Amazon SES on NodeJS

Juha — Mon, 06 Nov 2023 15:16:46 +0000

Here's a quick example of sending an email with Amazon SES (Simple Email Service).

In this example we are using a few libraries:

Nodemailer provides support for embedded images etc.
EJS is a templating library, which we use to build our HTML email
dotenv loads environment variables from a .env file

Install them:

npm install @aws-sdk/client-ses dotenv ejs nodemailer

Provide your AWS region and secrets in your .env file:

AWS_REGION=eu-central-1
AWS_ACCESS_KEY_ID=AKIAX...
AWS_SECRET_ACCESS_KEY=HMZHQ...

Create a simple HTML email template my-email.ejs:

<h1>Hi there</h1>
<p>This email is sent using Amazon SES with NodeJS. Nice!</p>

Create the javascript index.js for sending the email:

import 'dotenv/config';
import * as aws from "@aws-sdk/client-ses";
import nodemailer from "nodemailer";
import * as ejs from "ejs";

const sesClient = new aws.SESClient({
    region: process.env.AWS_REGION,
    credentials: {
        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
    }
});

const transporter = nodemailer.createTransport({
    SES: {
        ses: sesClient,
        aws: aws
    }
});

const mailHtml = await ejs.renderFile('./my-email.ejs');

transporter.sendMail({
        from: "sender@example.org",
        to: "receiver@example.org",
        subject: "Hello there via Amazon SES",
        html: mailHtml
}, (err, info) => {
        console.log(info.envelope);
        console.log(info.messageId);
});

If you get trouble with the import statements, you might need to add this to your package.json:

...
"type": "module",
...

There we go. This is a quick reference for developers looking to integrate Amazon SES using NodeJS.

Handle Lemon Squeezy webhooks with Node.js Express

Juha — Mon, 06 Nov 2023 09:09:46 +0000

You’ve set up your store on Lemon Squeezy and need to handle webhook events? Let's look at a quick 'n simple NodeJS example.

What are webhooks good for?

Webhook events are instrumental in tracking various elements such as:

Orders
Subscriptions
Payments
License Keys
And more...

In essence, webhooks are about efficiency and responsiveness. They provide a way for your Lemon Squeezy store to communicate with your server or other applications in real-time.

Webhooks cut down on the need for manual checks and processing. This real-time data transfer enables systems to react instantly to events as they occur, which is essential for a seamless and automated online venture.

Example of Webhooks on Node & Express

Let's look at what the webhook listener generally looks like.

This example requires two installed packages:

npm install dotenv express

The listener needs your signing secret, which you get when setting up the webhook endpoint at your Lemon Squeezy dashboard. Place the signing secret into your .env file.

echo "SIGNING_SECRET=MySecret" >>.env

Now the actual webhook listener with ExpressJS:

require('dotenv').config();

const crypto = require('crypto');
const express = require('express');

const app = express();

app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
    // Make sure the request is actually from Lemon Squeezy
    //
    const hmac = crypto.createHmac('sha256', process.env.SIGNING_SECRET);
    const digest = Buffer.from(hmac.update(req.body).digest('hex'), 'utf8');
    const signature = Buffer.from(req.headers['x-signature'] || '', 'utf8');

    let sigOK = false;
    try {
        sigOK = crypto.timingSafeEqual(digest, signature);
    } catch (err) {
        console.log("ERROR: timingSafeEqual: " + err);
    }

    if (! sigOK) {
        console.log("ERROR: Invalid signature");
        res.status(400).send("ERROR: Invalid signature");
        return;
    }

    // Parse the webhook's data as JSON
    const event = JSON.parse(req.body.toString());

    console.log(`${event.meta.event_name} webhook received`);

    // Explore the event object's contents, and do your thing with it
    console.log(event);

    res.send();
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server listening on port ${PORT}`);
});

Look up the data included in different webhook events from Lemon Squeezy docs.

This was a quick reference designed for developers who need a refresher on integrating Lemon Squeezy webhooks with Node.js. It's the nuts and bolts of the setup process to get you started.

Monitor Website Response Time with cURL [command example]

Juha — Mon, 06 Nov 2023 08:41:15 +0000

Discover how to measure your website's response time using the curl command, and how it can help you increase traffic and performance of your webpage.

Understanding Server Response Time

Server response time, also known as Time to First Byte (TTFB), is the time it takes for the server to process a web request and send the first byte back to the user.

Think of it as the pause before your web pages begin their journey to the user's screen.

Why Measure The Response Time?

Server response time is a critical part of overall website performance and loading times.

Paying attention to response times has huge benefits:

Performance Bottlenecks: Server response time helps identify potential performance issues on the server, such as slow database queries, excessive load, or under-resourced infrastructure.
User Experience: Quickly loading pages enhance user experience because people do not want to wait for slow-loading pages. A fast response time increases user satisfaction and the desire to use your site.
Search Engine Visibility: Search engines like Google evaluate a site's loading speed as part of its search engine optimization (SEO). Faster pages receive a higher ranking in search results, which helps increase organic traffic and your visibility.

Measuring Response Time with cURL

cURL is a versatile tool commonly found in MacOS and Linux operating systems. It can be used to make various types of network requests.

Server response time is measured with cURL as follows:

curl -s -o /dev/null -w "%{time_starttransfer}\n" https://www.enstai.fi/

cURL measures how long it takes for the web page at https://www.enstai.fi/ to generate a response. The command returns the response time in seconds.

Real-World Example

juha@MacBook ~ % curl -s -o /dev/null -w "%{time_starttransfer}\n" https://www.enstai.fi/
0.152016

Here, the response time is 0.152016 seconds, or 152 milliseconds (ms).

According to Google, a good response time is under 200 ms, or less than 0.2 seconds.

It seems that enstai.fi was quicker to respond, which is great!

Conclusion

In the digital age, speed is of the essence. Monitoring your website's speed with cURL isn't just good practice — it's essential. This diligence is a part of what separates successful websites from the rest.

Keep in mind that each millisecond shaved off your response time can significantly elevate user satisfaction and enhance your position in SEO rankings.