DEV Community: Eduardo Zepeda

MCP servers are everywhere now!

Eduardo Zepeda — Wed, 04 Mar 2026 21:42:04 +0000

Eduardo Zepeda

Sep 11 '25

How to create a MCP server and MCP tools from scratch?

#ai #javascript #backend

Comments

5 min read

My Django Rapid Architecture short overview

Eduardo Zepeda — Fri, 27 Feb 2026 04:15:52 +0000

The other day, I was browsing Reddit, and found an Architecture proposal for Django projects called “Django Rapid Architecture”. It’s a small document with a few guidelines or principles. I’m fond of Django, and I think Django is of the best tools out there that you should use, so I read it and summarized it for you.

Django Rapid Architecture is a collection of curated patterns and idioms. It aims to create maintainable Django codebases. The author claims it derives from 15+ years of experience and 100+ production projects.

What’s wrong with Django’s default architecture?

Well, according to the author, Django’s “apps” are designed for reusable components, not project-specific business logic. Forcing all code into apps creates inflexibility: Migrations make early boundary decisions irrevocable, which inhibits the flexible refactoring necessary for dynamic projects.

Additionally, apps prefer “vertical encapsulation,” which groups views and models according to features. For real-world systems with interconnected business domains and interfaces, this is not ideal.

How to structure projects according to Django Rapid Architecture?

Instead of using Django’s default paradigm, structure by layers:

keep data (models/migrations)
interfaces (HTTP views/management commands)
Business logic (readers/actions) is separate.

This “horizontal encapsulation” aligns with Django’s natural layering, avoids early architectural lock-in, and better models complex domains.

Remember that Django is a monolith.

How does Django Rapid Architecture file structure looks?

And how does that look in practice? Well, something like this. The author talks about how we should embrace monoliths at first, since they’re less complex and more maintainable than microservices, and I agree totally.

Introducing unnecessary complexity just for the sake of it won’t allow you to iterate fast enough, which is crucial in this rapidly changing environment.

How does Django Rapid Architecture file structure looks?

And how does that look in practice? Well, something like this.

project/
├── actions
│ ├── some_domain.py
├── data
│ ├── migrations
│ │ ├── 0001_initial.py
│ └── models
│ └── some_model.py
├── interfaces
│ ├── management_commands
│ │ └── management
│ │ └── commands
│ │ └── some_management_command.py
│ └── http
│ ├── api
│ │ ├── urls.py
│ │ └── views.py
│ └── urls.py
├── readers
│ └── some_domain.py
├── settings.py
└── wsgi.py

The thing here is just to remember that code is divided into actions, data, interfaces, and readers.

Layers in Django Rapid Architecture

How to handle Data?

What to do with Models?

Put all Models, yes, all models, inside a single app called data.

Avoid ultra-large complex models with many methods; complex logic should be independent of models.

Avoid inheritance other than Django’s Model, so every developer can just look at the model and understand what it does.

What about Business logic?

Business logic code should live in plain functions with well-understood interfaces that operate on model instances, querysets, or plain values. Avoid complex inheritance, mixins, decorators, complex custom managers unless it’s absolutely necessary.

How to deal with Readers?

Serving a Django response involves three key parts:

The Query: Built in the view using a queryset. It defines which DB rows/columns to fetch, applying filters, joins, and optimizations. Some logic may be in custom querysets.
The Values: The data to be sent. Basic values come from model fields. Complex business logic often lives here, in model methods (e.g., get_absolute_url), transforming raw data into usable values for the response.
The Projection: The final shaping of data for the client. For a JSON API, this is serialization into a dict/list. For HTML, it’s template rendering. Both use the values from step 2. This is where you decide the exact output format.

Types of functions in readers

I’m oversimplifying this; there are tons of examples in the original source, which I encourage you to read thoroughly. But the main types of functions to extract and transform data from a model are:

Queryset functions encapsulate queryset constructions. Use composition and Higher Order Functions.
Producer functions produce values from model instances, functions that receive an instance and return something.
Projector functions, built on top of producers, return a dictionary that maps one or more names onto one or more values.

Actions

REST APIs are complex and non-uniform. Therefore, we should forget about all secondary HTTP verbs and stick with POST and GET.

Furthermore, we should make sure that a single URL maps to a single view, which responds only to GET or POST, not both. This is something similar to th RPC and gRPC paradigm, which I already wrote about.

Interfaces

SSR using Django templates is top-notch

Generating HTML on the server instead of using an API with react can increase productivity. HTMX combined with Django is recommended, the document also considers this approach superior to using React.

Nest interfaces to avoid complexity

You can organize your code to mimick your hierarchy of url segments.

project/interfaces/http/urls.py
project/interfaces/http/api/urls.py
project/interfaces/http/api/admin/urls.py
project/interfaces/http/api/admin/widgets/urls.py
project/interfaces/http/api/admin/widgets/views.py

Management commands

Django Management commands are also an interface and should be treated similar to views.

Where can I learn more about Django Rapid Architecture?

Where can I learn more about Django Rapid Architecture? Remember that this text is only an overview of the main ideas. If you want to dive into this architecture proposal called Django Rapid Architecture, read the original source. I promise it’s short, only a few pages long, with a few more examples and the justification of some decisions.

I've built a Swiss Tables interactive simulator so you can understand how they work internally and how they offer superior performance compared to Buckets

Eduardo Zepeda — Tue, 23 Sep 2025 21:38:18 +0000

Eduardo Zepeda

Sep 22 '25

Swiss Tables the superior performance hashmap

#architecture #database #go

Comments

7 min read

Swiss Tables the superior performance hashmap

Eduardo Zepeda — Mon, 22 Sep 2025 02:00:00 +0000

The Hash Map Got a Swiss Army Knife Upgrade

You’ve probably used hashmaps in the past, but the thing here is, you use it and you forget about the internals you limit your knowledge of hashmaps to getting and setting keys, you iterate over them probably, but that’s all.

hashmap.get("key")
hashmap.set("key", value)
// or
hashmap["key"] = value

Every worth-learning language has its own implementation, you know, the way it works under the hood, and most devs just don’t give a damn about it, which is fine, I support high level abstractions.

The thing here is that, recently,Go decided to change its default hashmap implementation from Buckets to Swiss tables looking for better performance, ~~trying to mimick Rust’s performance~~. Which already paid off for some companies saving them hundreds of gigabytes.

By the way it was Google who created Swiss tables (well one of its engineers), and also protobuffers and GRPC, they’re always improving the performance of what already exists.

Swiss Tables simulator in real time

I coded a Swiss Tables simulator on my blog, however I can't inject Javascript here. So you have to go to my Swiss Tables entry.

So, What’s the Big Idea behind Swiss Tables? It’s All About Metadata.

Traditional open-addressing hash maps store your key-value pairs in a big array. When you insert an element, you hash the key to find a “home” slot. If that seat is already taken, you probe for the next available spot and so on.

Slot 1	Slot 2	Slot 3	Slot 4	Slot 5	Slot 6	slot 7	slot 8	slot 9	slot n
→	→	→	→	↓
1	1	1	1	Free

So… what’s wrong with this? Well, nothing really, just that in certain scenarios it can become messy. To find an element, or to confirm it’s not there, you might have to traverse half the array. That’s slow.

Slot 1	Slot 2	Slot 3	Slot 4	Slot 5	Slot 6	slot 7	slot 8	slot 9	slot n
1	1	1	1	1	1	1	1	Free

Swiss Tables attack this cumbersome problem with a brilliant idea: a separate metadata array. For every slot in the main data array, there’s a corresponding byte in the metadata array.

This byte isn’t just a tombstone or an empty flag; it’s a packed suite of useful information. The most crucial part is the 7 bits from the hash of the key stored in that slot.

Meaning Control bit	Control bit	Bit 1	Bit 2	Bit 3	Bit 4	Bit 5	Bit 6	Bit 7
Empty	1	0	0	0	0	0	0	0
Full	0	0x3A
Deleted	1	1	1	1	1	1	1	0

This is a game changer. Why? Because to check if a slot might contain our key, you don’t need to touch the main data array at all. You can first check the metadata. This is a huge win for performance.

A Step-by-Step Walk Through the Swiss table data structure

Alright, so we’ve talked about the metadata esoteric magic. But how does it actually works, step-by-step, when you insert my_app[“value”] = value and when you ask for my_map[“apple”]?

Inserting a key and its value in a Swiss table

When you look up a key the overall goes this way:

The key is hashed.
The group or bucket is decided using h1.
The target slot or block is located using h2.
If the slot contains our key already you just update it
If no slot contains our key, you look for an empty slot.
If all slots are taken you jump to the next group

Hash the key

First, the key “apple” is run through a robust hash function. This produces a full 64-bit hash value. Let’s say it’s something like 0x5A3F9C42B1D08E3A (a beautiful, random-looking number). Now, Swiss Tables perform a neat trick: they split this hash into two parts:

57 bits (Called h1)
7 bits (Called h2)

H1	…	H1	H2
10101110	…	11100010	0x3A

Decide the initial group using h1

The first 57 bits (0x5A3F9C42B1D08E…): This part of the hash determines which initial group or “bucket” the key belongs to.

0x5A3F9C42B1D08E % 2

Locate target block

The last 7 low bits (0x3A): This is the “probe index.” It tells the map which of the 8 or 16-slots (or “blocks”) to start looking in.

Retrieving the value of a key

When you look up a key the overall goes this way:

The key is hashed.
The group or bucket is decided using h1.
The target slot or block is located using h2.
The CPU takes the 7-bit (h2) hash snippet from our key and loads it into a special register.
It then compares this single value against all 8 or 16 metadata bytes in the target block— simultaneously. This is done using SIMD (Single Instruction, Multiple Data) instructions, basically parallelism.

Now let me explain you the steps.

Finding the block using the 7-bit hash

The map takes the 7-bit (h2) probe index (0x3A) and uses it to locate the specific 16-slot block where “apple” should be. This calculation is incredibly fast.

Use SIMD to compare the slots

This is the SIMD (Single Instruction, Multiple Data) step we love. The CPU loads the 16 metadata bytes from that block. For each byte, it checks two things:

Is the slot occupied? (A special bit in the metadata byte indicates this).

Does the 7-bit (h2) fingerprint in the metadata match our fingerprint (0x3A)?

It does this for all 16 slots AT ONCE. And this is where the magic happens, I’ll elaborate in a moment. The result is a bitmask of potential candidates.

Handle collisions if they exist

A matching 7-bit fingerprint doesn’t mean the keys are equal ; it just means they might be equal. It’s a pre-filter. It’s designed to be fast, not perfect. The full 57-bit hash (h1) (and eventually the actual key comparison) is the final arbiter.

If there are any matches (say, slots 2 and 9 had the same 7-bit (h2) fingerprint and are occupied, a collision occurred), the map finally goes to the main data array. But it’s not guessing anymore. It goes directly to slots 2 and 9 and performs a full key comparison: stored_key == “apple”? This is the only expensive operation, and you’ve minimized it to just one or two checks, lukcily you won’t have more than two collisions.

Retrieve the key’s value

Finally, if a full key matches, it returns the value. If not, or if the SIMD step found no candidates, it can confidently say the key isn’t in the map. This last part—the negative lookup—is where Swiss Tables absolutely dominate traditional maps that have to trudge through long probe sequences.

Why are Swiss tables so fast? SIMD and the 16-Slot Block

Here’s where the real genius kicks in. Modern CPUs don’t need to check things one byte at a time. They are surprisingly good doing operations in parallel. Swiss Tables are designed to exploit this by grouping slots into blocks (typically of 16).

In just one ~~blazingly fast~~ operation, the CPU creates a bitmask. A 1 means “the hash snippet matches,” a 0 means it doesn’t. Only then, for the slots that might be a match, does the code actually dereference the pointer to the main data array to do a full key comparison.

This is the killer feature of Swiss Tables. It minimizes expensive memory accesses and leverages the CPU’s parallel processing capabilities.

It makes lookups, especially for missing keys, super fast. You’re not traversing a chain or a long probe sequence. Which, as you may know, impacts Big O performance

Why Should You Care? The Swiss tables Advantages

This architecture isn’t just a neat bloring and hypothetical academic exercise. It translates into real tangible benefits that nerdy devs will see reflected in their applications, ~~transforming a 0.0004s into a 0.00002s execution~~. According to Go’s official page, performance went up by about 63% compared to Buckets implementation.

1. Blazing Fast Lookups: The combination of the metadata filter and SIMD makes find() and contains() operations significantly faster than in most traditional maps. It’s not a small margin; we’re talking multiples in many benchmarks.

2. Super Efficient Memory Use: Swiss Tables are typically implemented as “flat” structures. This means they store keys and values directly in the array, not as separate allocated nodes. This greatly improves cache locality—the data you need is probably already in the CPU’s fast cache(You should know the drill: L1, L2, L3 caches)—and it avoids the memory overhead of pointers used in chained implementations. This makes them superior to other hashmaps implementations in terms of memory usage.

3. Smarter Resizing: The metadata array makes the internal control logic much smarter. The map can make better decisions about when to rehash and how to distribute elements, keeping performance more consistent as the load factor increases.

Ok but, what about Swiss tables disadvantages

However, it’s not all sunshine and rainbows, of course, everyhing in tech is trade-off. The separate metadata array does consume extra memory (about 1/16th to 1/8th of the main array), which is usually a great trade-off because memory is one of the cheapest resources.

Also the implementation is complex—thankfully, but that doesn’t involve you, because you’re going to use it the same way you have always used it.

How to create a MCP server and MCP tools from scratch?

Eduardo Zepeda — Wed, 17 Sep 2025 00:00:32 +0000

Why Would We Want to Create a MCP Server?

Creating a MCP server allows us to connect an LLM or AI to real-time data, personal data, or other data sources.

I previously wrote a post where I explain how the Model Context Protocol (MCP) works internally; you can check it out if you’re not satisfied with just a recipe and want to learn more.

In this post, I’ll detail how to create a MCP server. We’re going to make one that solves one of the most embarrassing LLM errors: not being able to count the number of r’s in variations of the word strawberry. For example: strawberrrry or strawberrrrrrry.

If you’re not a bot, you already know that counting letters is a pretty trivial task for a human.

On the other hand, for an LLM it’s almost impossible due to how it works—based on tokens. AI can create art and code, even though it isn’t a consciou entity, but it can’t count letters. Contradictory, isn’t it?

For now, we’ll turn this into an educational exercise on how to deploy a MCP server.

Requirements to Create a MCP Server in JavaScript

We’ll start with a Node installation—you know, the result of running: npm init -y, and we’ll create the index file using the Linux touch command

.
├── index.js
├── package.json
└── package-lock.json

Set package.json as a Module

Inside the package.json file, change or create the type property and assign it the value module, so npm treats it as a module.

"type": "module"

Install the Library

A MCP server requires the official MCP server SDK, just install it via npm. We also need zod, which, ~~if you’re unlucky enough to use JavaScript~~ , is used to validate data.

npm install @modelcontextprotocol/sdk@1.16.0 zod@3.25.76

Create a MCP Server

Afterward let’s create a MCP server just initiliazing a new McPServer object

import {McpServer} from "@modelcontextprotocol/sdk/server/mcp.js"

const server = new McpServer({
    name: 'Strawberry Count',
    version: '1.0.0'
})

Create MCP Tools in a MCP Server

Next, we’ll define the tools, or mcp tools, that allow us to receive a parameter from the LLM so we can do whatever we want with it—in this case, count the r’s. I already talked about mcp tools in my introduction to the Model Context Protocol.

// server.tool("<Name>", "<Description>", {
server.tool("Strawberry Count", "Count the number of r's present in an strawberry variant", {
    param: z.string().describe("The strawberry variant, it can have a variable number of r's")
},
    // callback with the param
    // AI will detect this param
    async ({ param }) => {
        return {
            content: [
                {
                    type: 'text',
                    text: `The word has: ${param.toLowerCase().split("").filter(letter => letter == "r").length} r's`
                }
            ]
        }
    }
)

One thing to notice here, we’re counting the r’s manually—no tricks whatsoever. We process the string we receive and return the number of r’s.

Also, I want to highlight how awesome is the dark magic that the LLM uses to get our custom param. Our LLM detects the param that we want to receive from the user’s input using as context the description information that we passed to the describe method.

Obviously, your mcp tool won’t do something as useless as counting r’s—you could fetch data from an API, process it, get info from the file system, or even from another LLM—whatever you want.

Where Does the LLM Get Its Context From?

For this example, we’ll use STDIO (Standard Input Output). But in the MCP introduction I talked you a little bit about its alternatives: SSE and HTTP Stream.

In this case, it’s basically the user’s text input.

const transport = new StdioServerTransport()

Run the MCP Server to Read from STDIO

Now we’ll connect this transport to the MCP server so it can read directly from STDIO.

await server.connect(transport)

Connecting the MCP to Other Applications, like Claude Desktop

We can connect this MCP server to any program that supports MCP so we can use it.

For example, for Claude Desktop we would fill out the claude_desktop_config.json file.

Notice how we declare that the MCP server should run with the npx command followed by the list of arguments in order.

{
    "mcpservers": {
        "name": {
            "command": "npx",
                "args": [
                    "-y",
                    "node",
                    "<full_path_to_js_file>"
                ]
        }
    }
}

If you wanted to use TypeScript instead of JavaScript, you could do something like this:

{
    "mcpservers": {
        "name": {
            "command": "npx",
                "args": [
                    "-y",
                    "tsx",
                    "<full_path_to_ts_file>"
                ]
        }
    }
}

Analyzing the MCP Server with the Inspector

How we test that our MCP works? Claude’s inspector lets you test and debug MCP servers. You can view the tools you’ve created and simulate their function—however, these don’t use an LLM. It’s a plain server, functioning as if we were the LLM.

To run it, you can use npx and pass the server command:

npx -y @modelcontextprotocol/inspector <mcp_server_command>

I wasn’t able to run the command using substitution. I tried using the relative and absolute directory, but I couldn’t connect to the server—I’m not sure why.

However it did work by manually filling in the data in the Inspector’s graphical interface.

After running the inspector, we’ll have a server running on port 6274 (by default, though this can be changed).

npx -y @modelcontextprotocol/inspector npm index.js
npx -y @modelcontextprotocol/inspector npm /home/dir/mcp-server/index.js

Next, fill in the transport type and commands in case you had the same issue I did.

If we click on “list tools,” it’ll detect the tool we just created.

By clicking on List tools, and then on the name of the tool, will activate and we’ll be able to pass it our parameter: a strawberry variant with as many r’s as we want.

Just remember, this parameter is what we’d receive directly from our LLM—it would be the one responsible for parsing the user’s input and returning the parameter accordingly, so don’t mess with the input.

As you can see, the code works. The MCP server returns our message. In a real-world setting, this would be received by the LLM and would tell the user the correct number of r’s in their strawberry variant—without making a fool of itself, as it would normally do.

Zero Downtime Migrations: Shadow Table Strategy Explained

Eduardo Zepeda — Tue, 16 Sep 2025 17:37:13 +0000

Eduardo Zepeda

Sep 11 '25

Zero Downtime Migrations: Shadow Table Strategy Explained

#database #backend #sql

Comments

9 min read

Zero Downtime Migrations: Shadow Table Strategy Explained

Eduardo Zepeda — Mon, 15 Sep 2025 22:14:41 +0000

Picture this: It’s 2 AM, you’re deploying a “simple” column type change to production, and suddenly your entire application is down because the table lock is taking forever. Your phone starts buzzing with angry Slack notifications, and you’re frantically trying to explain to your team why the “5-minute migration” has been running for 30 minutes.

What’s the Shadow Table Strategy?

The shadow table strategy is like having a stunt double for your database table. Instead of modifying your original table directly (and potentially bringing your application to its knees), you create a ~~shadow clone~~ new table with the desired structure, gradually copy data over, and then perform a lightning-fast switcheroo.

Here’s the basic flow:

What Problem Is This Solving Shadow Table Strategy?

Traditional ALTER TABLE operations can be absolute nightmares in production if you’re dealing with websites that have billions of records. When you run something like ALTER TABLE users MODIFY COLUMN id BIGINT, most database engines will:

Lock the entire table for the duration of the operation
Block all reads and writes while restructuring the table
Take forever on large tables (we’re talking hours for billions of rows)
Risk timeouts that leave your database in an inconsistent state

The shadow table strategy solves these problems by breaking the database migration into smaller, more manageable chunks that don’t require long-running locks. Your application stays online, users stay happy, and you don’t get notifications at 3 AM.

What about smaller tables

If your table doesn’t have millions of rows and it’s not critical that the database keeps running, you can always just send an email notifying your users that your app will be under maintenance for a short period.

I mean nobody is going to hate you if your furry images site is down for a couple of hours, put a “touch some grass” page and perform the migration, don’t obsess unnecessarily about your app’s performance.

However, if that’s not the case and the business is losing money for every second that the database is locked…

Steps to Perform a Table Modification Using Shadow Table Strategy

Let’s walk through a real-world example where we need to change a user ID from INT to BIGINT because we’re approaching the 2.1 billion limit.

Stonks. Congratulations if you’re the one running the show.

Step 1: Create the Shadow Table

First, create your new table with the desired structure:

-- Create the shadow table with the new structure
CREATE TABLE users_new (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;

-- Copy indexes from the original table
CREATE INDEX idx_users_email ON users_new(email);
CREATE INDEX idx_users_created_at ON users_new(created_at);

Step 2: Set Up Data Synchronization

This is where things get interesting. You need to keep the shadow table in sync with the original while your application continues to operate like if nothing were happening.

Yes, you’re duplicating writes and running two tables instead of one. For this there are two approaches:

Use database triggers

-- Create triggers to keep shadow table in sync
DELIMITER $$

CREATE TRIGGER users_insert_sync
    AFTER INSERT ON users
    FOR EACH ROW
BEGIN
    INSERT INTO users_new (id, name, email, created_at, updated_at)
    VALUES (NEW.id, NEW.name, NEW.email, NEW.created_at, NEW.updated_at);
END$$

CREATE TRIGGER users_update_sync
    AFTER UPDATE ON users
    FOR EACH ROW
BEGIN
    UPDATE users_new 
    SET name = NEW.name, 
        email = NEW.email, 
        updated_at = NEW.updated_at
    WHERE id = NEW.id;
END$$

CREATE TRIGGER users_delete_sync
    AFTER DELETE ON users
    FOR EACH ROW
BEGIN
    DELETE FROM users_new WHERE id = OLD.id;
END$$

DELIMITER ;

Synchronize data at Application-Level

If you prefer, you can sync the data through your application’s logic instead.

def update_user(user_id, changes):
    # Original write to main table or database
    original_db.execute("UPDATE users SET ...")

    # Shadow write (with transformation)
    shadow_db.execute(
        "UPDATE users_new SET name=? ...",
        data['email']
    )

Step 3: Copy Existing Data in Batches

Now comes the bulk data migration. Never try to copy everything at once , that’s a recipe for a digital hecatombe. Remember the worker pool pattern’s reason of existance.

Make sure you have enough resources and consider doing this during low-traffic periods:

-- Copy data in manageable batches to avoid long locks
SET @batch_size = 10000;
SET @min_id = 0;
SET @max_id = (SELECT MAX(id) FROM users);

-- Loop through batches (you'd typically script this)
WHILE @min_id < @max_id DO
    INSERT INTO users_new (id, name, email, created_at, updated_at)
    SELECT id, name, email, created_at, updated_at
    FROM users
    WHERE id > @min_id AND id <= @min_id + @batch_size
    ON DUPLICATE KEY UPDATE
        name = VALUES(name),
        email = VALUES(email),
        updated_at = VALUES(updated_at);

    SET @min_id = @min_id + @batch_size;

    -- Give the database a breather
    SELECT SLEEP(0.1);
END WHILE;

Step 4: Verify Data Consistency

Before you make the switch, you better be damn sure everything copied correctly:

-- Check row counts match
SELECT 
    (SELECT COUNT(*) FROM users) as original_count,
    (SELECT COUNT(*) FROM users_new) as shadow_count;

-- Check data integrity with checksums
SELECT 
    (SELECT SUM(CRC32(CONCAT(id, name, email))) FROM users) as original_checksum,
    (SELECT SUM(CRC32(CONCAT(id, name, email))) FROM users_new) as shadow_checksum;

-- Spot check some random records
SELECT * FROM users WHERE id IN (1, 1000, 50000) ORDER BY id;
SELECT * FROM users_new WHERE id IN (1, 1000, 50000) ORDER BY id;

Step 5: The Great Switcheroo

Here’s where your heart rate spikes. The actual table swap should be lightning fast, like an ~~unnecessary~~ Rust new shiny library:

-- This should take milliseconds, not minutes
START TRANSACTION;

-- Drop the triggers first (no more syncing needed)
DROP TRIGGER users_insert_sync;
DROP TRIGGER users_update_sync;
DROP TRIGGER users_delete_sync;

-- Rename tables atomically
RENAME TABLE users TO users_old, users_new TO users;

COMMIT;

Step 6: Clean Up and Verify

Clean up and ~~realize everything went wrong~~ celebrate.

-- Verify everything is working
SELECT COUNT(*) FROM users;
SELECT * FROM users LIMIT 5;

-- After you're confident everything works (give it a day or two, nevermind, maybe a couple of months)
DROP TABLE users_old;

Handling Tables with millions of QPS

For tables with millions of QPS, or million of concurrent users, you can opt for using a queue instead of directly writes.

Use a write buffer : Queue shadow writes in Redis/Kafka if database just can’t handle dual writes.

Column mapping hell? Use views to abstract renames:

  CREATE VIEW users_combined AS
  SELECT id, COALESCE(new_id, id) AS unified_id FROM users_new
  UNION ALL SELECT id, name FROM users WHERE NOT EXISTS (...);

Common Errors While Implementing Shadow Tables

Let me save you some pain by sharing some common mistakes I’ve seen and read about ~~and made~~ :

Forgetting to Handle Foreign Key Constraints : If other tables reference your table, you’ll need to temporarily disable foreign key checks or handle the references carefully. Don’t just ignore this, your data integrity depends on it.

Not Testing the Triggers Thoroughly : Triggers can fail silently or behave in strange ways under load. Test them with realistic data volumes and concurrent operations before going to production.

Underestimating the Sync Lag : During heavy write periods, your triggers can let you down. Monitor the sync status and be prepared to throttle writes if necessary.

Inadequate Monitoring : You need to be aware during the migration progress, sync lag, and any errors, not after things go wrong. Implement monitoring before you start, not while everything is falling apart.

Poor Rollback Planning : Always have plan B. If something goes sideways during the switchover, you need to be able to revert quickly.

Handling Shadow Tables in Distributed Systems

Consider service discovery, connection pooling, and cache invalidation. When you rename your tables, remember that every service instance needs to know about the change simultaneously.

This often means implementing a coordinated deployment strategy where you temporarily stop traffic, perform the switch, and afterwards restart services.

Consider using feature flags, like the one I told you about in my post about deployment patterns, to control which table your application reads from. This gives you fine-grained control over the migration and allows for gradual rollouts.

Databases with read replicas

Ensure your shadow table has been fully replicated before performing the switch. Monitor replication lag carefully, as the switch needs to happen consistently across all replicas.

Monitoring Performance During the Transition

When executing the migration you’re essentially running two tables in parallel, with its corresponding I/O usage, check disk usage and monitor it.

Triggers add overhead to every single INSERT, UPDATE, and DELETE operation. Set up alerts for unusually long trigger execution times.

Compare row counts between the original and shadow tables during the process, if the difference between both grows, there is something fishy going on.

Handling Unique Constraints and Foreign Keys

For unique constraints, you need to ensure the shadow table maintains exactly the same uniqueness guarantees as the original table.

When copying data in batches, use INSERT … ON DUPLICATE KEY UPDATE or equivalent upsert logic to handle potential duplicates, especially if your application continues to write data during the migration.

For Foreign Key constraints, you can disable checks during the migration, however you’re risking data integrity, it’s always a trade off. Use deferred checks (If you’re using PostgreSQL) or disable FK checks (MySQL SET FOREIGN_KEY_CHECKS=0)

Alternatively, you can create the foreign key constraints on the shadow table and update referencing tables after the main migration finishes.

Dealing with Triggers and Stored Procedures

Existing triggers and stored procedures can be a pain in the…

Firstly, list all existing triggers on your table. You’ll need to recreate these triggers on the shadow table, just remember that execution order is paramount.

Your sync triggers should generally be executed last , after all business logic triggers have run.

Stored procedures that point to your table, should be renamed after the migration. Use synonyms or views to minimize the number of procedures requiring updates.

Test trigger interactions thoroughly in a staging environment to prevent unwanted surprises.

Verifying Data Consistency Before Cutover

Never skip this step, no matter what.

Compare aggregate values like sums, averages, and counts. Use checksums or hash your data to double-check that row data matches exactly between tables. Statistics is your friend, get the correct number of records to sample to get that 95% confidence level.

Create automated consistency check scripts that you can run repeatedly during the migration that let you know if everything is going well.

Checksum tools (like pg_checksums or custom COUNT(*) + hash_agg() queries) are your friends.

The Rollback Plan (When Everything Goes to Hell)

Are you familiar with Murphy’s Law? Well you know the drill then.

The simplest rollback is to reverse the renaming operation. Keep your original table as

_old, or whatever you want, during the cutover period , so you can quickly rename it back if Murphy shows up. This should be blazingly fast.
For more complex rollbacks, you might need to reverse-sync data from the shadow table back to the original. Consider maintaining reverse triggers during the cutover period, it adds complexity but you’ll have more options available

When production is on fire, you don’t want to be figuring out rollback commands on the fly. Always document your rollback procedures clearly , practice in stagging environments.

Consider implementing application-level rollback mechanisms using feature flags or configuration changes. I talked a little bit about them in my post about deployment patterns. Sometimes it’s faster to point your application back to the old table than to perform database-level changes.

Tools to help you

There are some tables that can help you to ease the process of migrating a table:

Tool	Best For	Killer Feature
gh-ost	MySQL	Triggerless replication
pg_repack	PostgreSQL	Online table reorganization
Liquibase	Cross-DB	Change tracking
Debezium	CDC streaming	Kafka integration

Wrapping Up

The shadow table strategy is far away from perfect and many things can occur, you can f'up your boss' database so take things calmly, don't let them pressure you, and don't work alone.

Remember that every database and application is different. What works for a read-heavy tables might not work for a write-heavy tables. Always test in an environment that mimics production as closely as possible.

Don’t be afraid to abort the migration during the last minute if things aren’t going according to plan, it’s all about keeping things working not about playing the hero. Yes! you're not Saitama equivalent of programming.

AI-generated Art and AI-generated code are treated differently

Eduardo Zepeda — Sat, 13 Sep 2025 20:29:58 +0000

Today, while doom scrolling on Zuckerberg’s social network, the algorithm recommended me an image of Sakura Card Captors in the style of the Spanish painter Remedios Varo.

When I checked the comments—I don’t even know what I gain from doing that—I noticed that the most liked ones expressed strong disdain for artificial intelligence. A normal behavior if you’re in the middle of AI overhype

Artists Hate AI, Devs Are Forced to Accept It

There’s a strong consensus among artists regarding AI.

Movements like #NOAI or Made with human intelligence have made their rejection of this technology very clear . The contempt seems to stem from how it was trained—using artists’ work without their permission, accused of plagiarizing something as personal as a style—and the fear of being replaced by this technology, which affects them economically.

[

On the other hand, there’s been a strong trend (whether organic or orchestrated, I don’t know) in the software world, to adopt AI as just another tool to increase the quality and quantity of code produced. Even when there’s resistance, it’s more focused on technical aspects and potential flaws rather than the ethical concerns of its training process.

This contrast fascinates me.

My Thoughts on Why AI-Generated Code and AI-Generated Art Are Treated Differently

It’s not about one being right or wrong—it just really catches my attention.

Perhaps it’s because art is a direct form of visual and emotional communication. The fact that it’s generated by a machine might be perceived as an inferior form of expression or a threat to something considered purely human.

In contrast, code, by its functional and abstract nature, lacks that emotional weight, and the fact that a computer program generates it goes completely unnoticed.

Humans evolved using sight as a survival tool, so anything perceived visually will have a more significant impact. Code, as an abstraction of logic, is very recent and wasn’t part of our species’ evolutionary pressures or material reality. Plus, given its nature, it’s far less visual. Remember, code isn’t the final product—it’s an abstraction.

Code Is Pragmatic, Art Isn’t

Code was created to abstract, in a language closer to human speech, a series of instructions for a computer, with a well-defined and deterministic purpose.

But art tells a different story.

Oscar Wilde would say:

“All art is quite useless.”

His statement doesn’t mean art is useless but that it exists for beauty and expression, not survival or moral instruction.

If there’s any truth to that, art is far more flexible than code and logical-mathematical systems.

I believe it’s precisely this flexibility that allows AI, combined with randomness, to function so differently for art and code.

The Role of Randomness in Generative Models and LLMs

AI can abstract patterns from its training dataset. Once it identifies those patterns or archetypes, it uses randomness to generate results that “fit” within them.

AI-Generated Art

An artist gathers stimuli from other artists, personal experiences, books, music… and “mixes” them to create something new. The result is something original that retains certain references or characteristics of the works that inspired it, no matter how subtle.

All of this happens consciously, whereas AI does it unconsciously—or at least that’s what Searle would suggest .

AI-Generated Code

In the case of AI-generated code, the process is practically the same. The AI detects patterns in numerous code samples and then generates new code, different but based on the patterns the LLMs have “learned.”

In both cases, randomness allows for something new—not an exact copy of the originals it was trained on (as long as it doesn’t overfit).

Randomness Impacts the Differences Between AI-Generated Art and Code

As I mentioned earlier, art is far more subjective and variable than coding. There are millions (or more) ways to present a concept or image, which aligns perfectly with how LLMs or generative models work.

When it comes to writing code, however, the number of ways to achieve the same thing is much more limited. Writing a loop that counts from 0 to 100 in the same programming language might have a dozen solutions.

This number starkly contrasts with the potential ways to paint a concept, which could be practically limitless.

With code, it’s slightly different. Obviously, as the codebase grows, the number of possible solutions increases too. But here’s a crucial difference: unlike art, not all solutions are equally valid.

The Differences Between AI-Generated Art and Code

Let me expand on this. The subjective nature of art means all representations of the same concept are valid—a Picasso-style apple is just as valid as one painted by Velázquez or Carrington.

This isn’t the case with software. A variation of any complex program (a web crawler, a database, etc.) will behave differently in different scenarios, and there will be a superior or inferior version based on the code’s requirements.

These differences can be measured quantitatively: execution time, memory usage, scalability, requests per second etc., leaving us with some solutions better than others.

Given this, AI will “get it right” less often and require more iterations when generating code. However, when creating art, the user will likely consider the result valid after just a few iterations.

This makes me think that, from my perspective, the non-deterministic nature of AI works better for creating art than for creating code.

Now, there’s another aspect I want to touch on regarding the differences between AI-generated code and AI-generated art.

The Contrast in Perception Between AI-Generated Code and AI-Generated Images

The final product of AI-generated art is the same product the user perceives. In contrast, the code AI creates doesn’t interact with the end user.

There’s no public backlash or protests over AI-generated code because people don’t see it. Code, in itself, doesn’t evoke passion or anger—unlike when Devin AI promised to replace programmers . Maybe it’s because the visual stimulus of art is far more intense than a wall of text expressing relationships between abstract entities.

For proof, just look at the response to tools like Bolt, Lovable, or V0 , which were trained using developers’ code—also without their permission.

AI-Generated Websites

But what about websites? I’d argue that even if we observe the crystallization of code into pixels on a webpage, the reaction is entirely different from what we’d experience with art—despite both being perceived visually.

An AI-generated website (and perhaps the code itself) is completely indistinguishable from one made by a human. Plus, a website isn’t usually perceived as the result of human expression (especially in today’s internet).

But with art, it’s much easier to tell—hands with too many fingers, logical inconsistencies, even that default, generic style that’s become so characteristic. Or the now-popular Ghibli style that’s turned into a commodity.

AI-generated art stands out whereas AI-generated code is invisible.

I Built a Bloom Filter Data Structure Simulator

Eduardo Zepeda — Fri, 12 Sep 2025 15:49:12 +0000

Eduardo Zepeda

Sep 11 '25

I Built a Bloom Filter Data Structure Simulator

#database #architecture #backend

Comments

5 min read

I Built a Bloom Filter Data Structure Simulator

Eduardo Zepeda — Fri, 12 Sep 2025 15:47:15 +0000

Suppose you want to check whether a piece of data belongs to a larger set or not. Let’s say you’re Google and you want to check if certain url has been marked as spam, the dumb approach would be to iterate over every url marked as spam to see if you can find it. Sure, maybe you think, “I’ll save the spammy sites in a hashmap”, but then, a hashmap of the gazillion sites that exists in the internet? There must be a way that uses less space.

Even if you index those urls you still will have a not so good Big O performance, maybe O(log n) or O.

Sorry, this is an image, for the real simulator you need to visit my blog since I can't inject Javascript here.

Bloom filter simulator

This is an interesting data structure that’s probabilistic, it won’t have a 100% chance of returning what you wanna know, but the tradeoffs are interesting enough.

Ok but what’s a Bloom Filter?

A Bloom filter is a data structure that helps you check if an item might be in a set. It gives ~~blazingly~~ fast answers with very little memory. The trade-off is that sometimes it can say an item is present when it is not.

This data structure can produce false positives. But the good news are that there are not false negatives.

Because of this, Bloom filters shine when you care more about speed and space than absolute accuracy.

Check how they work, for simplicity we’re only using one word as the full set.

Where can I use bloom filters?

Bloom filters show up in those systems where quick lookups matter (No, your Tinder for pets probably doesn’t apply):

Databases : To check if a key might be in a table before doing a costly disk read. Of course we’re taking about millions of records, not tiny databases. (Cassandra, HBase, and Redis)
Web caches : To test if a page or object might be cached.
Distributed systems : To cut down on network calls when asking if a node has certain data.
Security : To quickly filter known bad URLs or email addresses, like in the first example I gave you.
Content recommendation systems : Where you want to avoid recommending content already consumed.

Bloom filters help reduce time and resource usage at scale, if you’re ok with some false positives.

How Does a Bloom Filter Work Internally?

A Bloom filter uses:

A bit array (all values start at 0).
A set of hash functions.

When you add an item, the filter runs it through each hash function. Each function gives you an index in the array. You set the bits at those positions to 1.

There are no deletions in classic bloom filters

Since you are not storing real data but the “pattern” produced by the hash functions, you have no way to tell which combination of data and hash function produced it, hence you cannot “delete” the item.

You cannot retrieve members from the set

Once you construct the bloom filter, you cannot know which items produced that patter from the filter itself, you can only know if something might belong or definitely doesn’t belong to the set.

Bloom filter collisions

However when you start adding more and more elements the chances of getting a collision (false positive) increase.

You can always add more hash functions to diminish the collitions but then the complexity and memory required increase.

Checking if an item exists

When you check an item, the filter does the same. If all the positions are set to 1, the item might be in the set (this is why it’s a probabilistic data structure). If any position is 0, the item is definitely not in the set.

Basic Bloom filter Flow

Here’s a simple outline that you can blatanly use to inspire you in the dark arts of bloom filters:

Decide the size of the bit array and initialize all elements to 0.
Pick a few independent hash functions.
To add an item:
To check an item:

Bloom filter pseudocode

Using pseudocode (I know, I should have used Javascript instead), it would look like this.

initialize bit_array of size m with all 0s
choose k hash functions

function add(item):
    for i in 1 to k:
        index = hash_i(item) mod m
        bit_array[index] = 1

function check(item):
    for i in 1 to k:
        index = hash_i(item) mod m
        if bit_array[index] == 0:
            return "not present"
    return "might be present"

Bloom filter flow chart

And if you are a fan of flow charts it would look like this

flowchart TD A[Start] --> B[Hash item with k functions] B --> C[Get indexes] C --> D{Add or Check?} D -->|Add| E[Set bits at indexes to 1] D -->|Check| F[Are all bits = 1?] F -->|Yes| G[Might be present] F -->|No| H[Not present]

Why not use hashmaps instead?

Well you could use some hashmaps approaches like buckets or Swiss tables but consider that you have to deal with collisions, also you can use many less intensive hash functions in a bloom filter whereas in hashmaps you need a strong hash function to avoid collisions which can consume some resources.

Also in a hashmap you store all the information as key-value pairs, whereas in a bloom filter you only store the results of the hash function, which can save a lot of space in memory.

When you shouldn’t use them?

If you need to delete items, standard bloom filters only support inserting new data.
If data is small, there is no sense in using a probabilistic approach with false positives, use a hashmap instead.
As I told you before, the more data you add, the chances of getting false positives increases, so don’t use it for data that grows a lot.

And that’s all, I wrote this entry because I read about this data structure in the System Design Interview Book, found interesting the fact that there is a probabilistic data structure out there, when must of the times you don’t deal with probability when you deal with data structures, quite the contrary, you look for determinism.

Some bloom filter libraries

Chances are there are already community-maintained libraries, so don’t worry about reinventing the wheel.

I wrote a guide about all the basic aspects of technical SEO that are often overlooked by web developers.

Eduardo Zepeda — Tue, 15 Apr 2025 19:38:31 +0000

Eduardo Zepeda

Apr 15 '25

A Technical SEO Basics Checklist Made For Web Developers

#seo #opinions #beginners

Comments

10 min read

A Technical SEO Basics Checklist Made For Web Developers

Eduardo Zepeda — Mon, 14 Apr 2025 06:02:21 +0000

Previously I told you how I made many mistakes in SEO when I migrated my website from Wordpress to Hugo, after that I started watching a lot of videos about SEO, especially Romuald’s videos (He is one of the biggest SEO influencers in Spanish speaking countries), I’ve also read The art of SEO and I tried to summarize everything I learned from him and the book in a short post, just for you, before AI bubble explodes, taking SEO with it.

My totally reliable source: Romuald Fons

I decided to focus on technical SEO because it’s the one that I understand, it’s less subjective and I’m more familiar with it.

I have examined many websites and I have noticed that many professional web developers leave Technical SEO basics out from their developments, it is certainly true that it is quite an extensive topic and it is far from what their expertise area, in my opinion, doing an average SEO is better than ignoring the topic entirely.

Simplifying SEO criminally, it can be divided in two:

Technical SEO : all those objective, measurable aspects, like the presence of a sitemap, meta tags, etc.
Content SEO : it’s a bit more subjective, it’s about what words to use, what sites to connect with

SEO is a black box and an art rather than science

Nobody knows exactly how the search engine algorithm works, so getting to the number one position in Google, or other engines, for a certain search keyword, is more of an art than a science.

Even if you manage to vaguely understand how the algorithm works enough to manipulate it, you will have to face the fact that the algorithm is a shape-shifting entity and what worked perfectly yesterday may not work today.

Despite the changes in the SEO world, the current SEO approach is still heavily tied to keywords; short phrases that you include in your website to tell search engines what your website content is about, so it can show it to the right users.

However, lately, Google has said that its algorithm is so sophisticated that it manages to evaluate how well a website responds to user intent and invites its users to focus on resolving user intent rather than keywords. Although, paradoxically, their advertising services are still strongly keyword oriented.

Technical SEO in web development

Technical SEO consists of a series of requirements that a website must meet to appear friendly to search engines, so that they index you in high positions and when a user searches in serach engines, you appear in the top positions.

This topic is very broad, but I hope to summarize in a way that you have a general idea and do not get lost in the sea of information that exists.

Sitemap.xml is the most important one of technical SEO basics

This is probably the most important element of technical SEO basics. A sitemap will tell search engines what pages your application has.

Sitemap diagram showing available urls

In many cases, a sitemap can be generated dynamically, some frameworks even have tools that allow you to do it in a few lines, such as Django (using its sitemap class).

Once created, you must tell the search engines where the url of your sitemap is located directly from your administration panel. If you don’t explicitly indicate it, they will search in the most common urls or, luckily in the robots.txt file.

Screenshot of Google's search console sitemap section

Robots.txt

A robots.txt file will guide search engines and crawlers on which URLs to ignore and which to inspect. In addition this file should include the location of the sitemap.

The URL for this file is always expected to be /robots.txt, so stick to this convention.

Here is an example of a robots.txt file

User-agent: *
Disallow: /*/tags/
Disallow: /*/categories/
Disallow: /*/search/

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

A robots.txt file is not for blocking crawlers or bots.

There is some confusion about this, and it’s pretty obvious but I’ll mention it anyway: crawlers can completely ignore the instructions in your robots.txt file , so you should not see it as a protection mechanism for your website, if a crawler wants to, it will ignore the instructions contained there.

Robots.txt won't protect you from crawlers

If any influencer tells you otherwise, they’re lying through his teeth. Furthermore, I dare them to stop a crawler just by using a robots.txt file.

Robots disallow everything

If you want to tell crawlers to ignore absolutely everything on your site, you could use something like:

User-agent: *
Disallow: /

The counterpart of robots.txt: humans.txt

As a curious fact, there is an initiative to popularize the idea of adding the counterpart of the robots.txt file, a humans.txt file and show the human part behind a web site, the soul in the machine or in the console (the “Ghost in the shell”?), I think it is a very nice idea to know how are the humans behind a web site. Unfortunately this project has little diffusion to date.

The often ignored Schema markup

Often present as a ld+json type script tag (although there are other valid formats), which can be found anywhere in your HTML document, it tells search engines what elements your web site has and how they relate to each other.

A Schema will provide information about the contents of a webpage

The different types of Schema are very complex and it is a whole topic to discuss, since they vary greatly according to the type of website.

A website that sells electronics will have a completely different set of Schema properties than a restaurant website, or a web application.

If you are completely lost, here is a prompt you can use for guidance, just write it to ChatGPT, DeepSeek or any other competent LLM:

You are an SEO expert, create the content of a ld+json tag, based on schema.org features, for a web page whose main topic is “x”, the content of the page consists of “y”, you can use placeholders for the variables using the following format: “z”, please.

Once you get the result corroborate it with the official documentation or with your schema markup validation tool.

Presence of Meta tags

The metatags that go in the head tag of your HTML are metadata about the content that can be used to help search engines understand your site better.

Within the metatags are especially important the Open Graph, as they are the standard for social networks to obtain information from your web pages, these meta tags are the ones that make one of your links look like this when you share it on social networks.

Social networks use metatags to display relevant information on a page.

There are some meta tag generators that you can use to generate all the boilerplate, or simple ask chatGPT.

Good performance is generally overrated in technical SEO basics

A website must provide a good user experience and be responsive, it matters, yes, but not as much as you think.

Content plays a much more important role than the speed of your website, it is common to see websites that are poorly optimized but with a good ranking in search engines, but don’t blindly trust me, double-check it, check google’s first page results using the following tool.

Lighthouse score for my portfolio page

Tools like Lighthouse are very useful to measure the performance of a website and also tell you how to improve it.

IMO this is one of the most overrated technical SEO basics’ aspect.

The most overlooked aspect of a technical SEO checklist: Well-designed website architecture

Make sure the website has a structure that allows search engines to “understand” it. What do I mean? I mean that the website is organized in a logical and hierarchical way that is understandable.

For example something similar to this:

Semantic structure of a website

Does the URL structure matter in SEO?

Yes, and a lot, you can use the urls to give your website the structure you think is correct so that it is coherent with the architecture you plan, this makes it easier for search engines to “understand” your website.

I’ve talked about this on my post REST API: Best practices and design

In the following URLs, notice how there is no way to know if Nawapol is a movie, or a director or a documentary:

/session-9/
/50-first-dates/
/nawapol-thamrongrattanarit/
/salt-of-the-earth/

It would be best to provide them with a consistent and more explicit structure:

/movies/psychological-horror/session-9/
/movies/comedy/one-hundred-first-dates/
/documentaries/photography/salt-of-the-earth/
/directors/nawapol-thamrongrattanarit/

You’re probably not using the correct HTML tags

Headings and SEO

Headings are the most important tags of your content, as they tell search engines how it is organized.

Make sure you use only one h1 tag, and hierarchical h2 tags up to h6, using them to give a hierarchical structure to your website.

HTML allows you to be very expressive in SEO.

Make sure you use only one h1 tag, and hierarchical h2 tags up to h6, using them to give a hierarchical structure to your website. There is much more to it than divs, anchors, img tags and video tags. HTML provides tags to help search engines and devices to better understand the content of a web page. Don’t just stick with those elements and research the rest of the HTML tags, such as:

article: Self-contained content that could be distributed independently.
section: Thematic grouping of content, typically with a heading.
nav: Navigation links for the document or site.
footer: Footer for a section or page, often containing metadata.
datetime: Machine-readable date/time (used within ).
aside: Content tangentially related to the surrounding content.
header: Introductory content or navigational aids for a section/page.
progress: Displays the completion progress of a task.
meter: Represents a scalar measurement within a known range.
cite: Citation or reference to a creative work (e.g., book, article).
q: Short inline quotation (browser usually adds quotes).
pre: Preformatted text, preserving whitespace and line breaks.
kbd: Keyboard input, indicating user-entered keys.
samp: Sample output from a program or computing system.
dfn: Defining instance of a term (often italicized).
output: Represents the result of a calculation or user action.
abbr: Abbreviation or acronym, optionally with a title for expansion.

Presence of internal links

They help search engines understand how your pages are related to each other. Make sure your links are valid and do not return 404 errors, and that the text you link to is related to the content of the linked page.

✅ <a href="/how-to-code-clean-code">How to code clean code</a>
✅ <a href="/how-to-code-clean-code">Learn how to code clean code</a>
❌ <a href="/how-to-code-clean-code">Click here to read my new entry</a>

Presence of external links

External links, consider it as a vote in favor towards other websites to indicate to search engines that the content you link to is important, research thoroughly about the attributes nofollow, follow, ugc and sponsored in the anchor tags and use them appropriately according to your intentions.

follow, the default value, tells search engines that the site they link to should be positively valued.
nofollow, search engines should not follow this link, ideal for advertising links, affiliate links or websites you want to link to but do not want them to be related to your content.
ugc, acronym for “User generated content”, ideal for social networks.
sponsored, sponsored link, usually advertising or affiliate links.

<a href="https://example.org/" rel="nofollow">The example website</a>
<a href="https://user-website.com" rel="ugc">Just check my website</a>

The Flesch Kincaid test

is a test based on the level of education required by a hypothetical reader to understand the content of your website, ~~unlike what your inflated ego thinks~~ , the higher the score the easier it will be to understand, which is better because it will be available to more readers.

Having said that, I would dare to say that the exact value does not matter so much, but that your text is easy to read and the reader flows through it.

Keep in mind that there are some plugins, like Yoast SEO if you use Wordpress, that take care of measuring it or you can program it yourself.

I have left some aspects that I do not consider so important, but that maybe I will add later, the important thing here is that you understand that it is not just to set up a website and that’s it, but you have to polish it so that users can find it and use it.

HTTPS instead of HTTP

It is quite rare to find modern websites that do not use HTTPS, especially when it is the hosting platforms that are responsible for configuring the servers automatically. In any case, make sure that your website uses HTTPS instead of just HTTP, as search engines favor secure connections.

And that’s all for now, I will be adding more information to the article if I consider it pertinent as the days go by.