DEV Community: kasia chil

Build Your Own SEO Bot: How to Automate Broken Link Audits with Python

kasia chil — Tue, 01 Sep 2026 04:51:23 +0000

A practical guide for website owners and content marketers to improve site health and retain traffic—no computer science degree required.
If you run a website, blog, or online business, you already know that broken links are the silent killers of SEO.
When a user clicks a link on your site and hits a "404 Not Found" page, two terrible things happen:

The user bounces. They leave your site, killing your retention metrics.
Google penalizes you. Search engine crawlers waste their "crawl budget" on dead ends, signaling that your site is unmaintained. Most website owners pay for expensive SEO tools like Ahrefs or Semrush to find these errors. But what if I told you that you could build your own automated SEO crawler in about 15 lines of Python? As a technical writer and content creator, I use Python to automate my daily workflows. Today, I am going to show you how to write a simple script that audits your webpage for broken links.

Why Python for SEO?

You don't need to be a developer to use Python. Think of it as Excel on steroids. By writing a tiny script, we can ask the computer to visit our website, find every single clickable link, and check if it is still alive—a process that would take hours to do manually.

The Python SEO Auditor Script

Here is a simple script using two popular Python libraries: requests (to visit the web pages) and BeautifulSoup (to read the HTML).

import requests
from bs4 import BeautifulSoup
def find_broken_links(url):
    print(f"🔍 Scanning URL: {url}\n{'-'*40}")

    # 1. Fetch the web page
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')

    # 2. Find all hyperlinks (<a> tags) on the page
    links = soup.find_all('a', href=True)

    # 3. Check each link's status
    for link in links:
        href = link['href']

        # We only want to check full web addresses (http/https)
        if href.startswith('http'):
            try:
                # Send a quick "HEAD" request just to check the status
                res = requests.head(href, timeout=5)

                # HTTP status codes 400 and above indicate errors (like 404)
                if res.status_code >= 400:
                    print(f"❌ Broken Link: {href} (Error: {res.status_code})")
                else:
                    print(f"✅ Healthy Link: {href}")

            except requests.RequestException:
                print(f"⚠️ Could not reach: {href}")
# Replace this with your own website article URL
target_page = "https://example.com/your-article-here"
find_broken_links(target_page)

How to Run This Without Installing Anything

If you aren't a programmer, looking at code can be intimidating. But you don't even need to install Python on your computer to run this!

Go to Google Colab (colab.research.google.com) — it is a free tool by Google that lets you run Python directly in your browser.
Click "New Notebook".
Paste the code above into the gray cell.
Change the "https://example.com/your-article-here" to a link on your own blog.
Click the "Play" button next to the cell. Within seconds, the script will scan your entire article and print out a report of exactly which links are healthy and which ones need to be fixed immediately.

The Business Value of Technical Content

Automating tedious tasks doesn't just save you hours of manual clicking; it actively protects your revenue. By running a simple script like this once a month, you ensure your site remains highly optimized for Google's crawlers, lowering your bounce rate and keeping your search rankings safe.

Coding isn't just for building apps anymore. It is the ultimate leverage for the modern digital entrepreneur.

From Code to Content: How I Turn My Technical Skills into a Freelance Business

kasia chil — Tue, 01 Sep 2026 04:08:23 +0000

Why the best way to leverage your tech background isn't always writing more code—it’s explaining it to the world.

As a technical writer deeply immersed in Python, FastAPI, and AI deployments, my daily life revolves around logic. I spend my time exploring microservices, testing LLMs, and understanding complex backend architectures. Code has become my primary way of understanding how digital products work.

But recently, I discovered a parallel path that is just as rewarding (and highly profitable): freelance technical writing.

When I started pitching articles and writing for developer platforms, I realized something surprising. The mindset required to build good software is the exact same mindset that makes you a successful freelance writer and business owner.

Here is how I translated my technical background into a thriving freelance content business—and why people in tech have an unfair advantage in the creator economy.

1. Applying "Agile Sprints" to Freelance Work

In software development, products aren't built in one sitting. Teams use Agile methodology, breaking projects down into manageable, one-to-two-week "Sprints."

I applied this exact framework to my writing business. Instead of staring at a blank page and getting overwhelmed, I treat every article like a software feature.

Planning: Outlining the headers and key takeaways (Writing the architecture).
Drafting: Getting the words on the page without worrying about perfection (Writing the MVP — Minimum Viable Product).
Editing: Polishing the text, optimizing for SEO, and fixing flow (Refactoring the code).

By treating freelance writing as a structured, iterative process, I completely eliminated writer’s block.

2. Debugging for the Reader’s Experience (UX)

Good code is clean, readable, and efficient. Good writing is exactly the same.

When building a web app, you care deeply about User Experience (UX). If a user can’t find the "Checkout" button in three seconds, they leave. In content creation, this translates to Reader Experience. If a reader can’t find the answer to their problem in your first three paragraphs, they bounce.

Working with code taught me to cut the fluff. I use formatting—bullet points, bold text, and clear H2 headers—the same way developers use comments and indentation in Python. It makes the "data" easier for the human brain to process.

3. Treating Freelancing Like a Micro-SaaS

Many writers struggle because they treat their work purely as art. Coming from the tech world, I treat my freelance business like a Micro-SaaS (Software as a Service) product.

Lead Generation: Pitching the right editors and platforms.
Client Onboarding: Clear communication, setting exact deadlines, and agreeing on deliverables.
Product Delivery: Submitting clean, well-researched, and perfectly formatted articles on time.

When you remove the emotion and treat your freelance career as a system, client acquisition becomes a predictable funnel rather than a guessing game.

The Takeaway

The tech industry is moving at lightning speed. Startups are building incredible AI tools, APIs, and cloud platforms every single day. But here is the catch: if no one can understand how to use these tools, they won't sell.

That is where the modern technical writer steps in. We act as the bridge between raw code and the end user.

If you have technical skills—whether you are learning to code, exploring data science, or studying system architecture—don't limit yourself to just building. Try explaining. You might just find that your words are as valuable as code.

Edge AI vs. Cloud APIs — Where the Real-World Developer Should Build Today

kasia chil — Tue, 01 Sep 2026 02:25:55 +0000

The choice between running inference on a local device and calling a remote API is no longer a theoretical debate. It now dictates latency, budget, and compliance for every production system that leans on large language models (LLMs). With quantized runtimes hitting single-digit millisecond marks and edge silicon becoming affordable, the calculus has shifted dramatically.

Latency: The User’s First Impression

Network round-trip is a hard floor: Even the fastest cloud endpoints add 150ms-400ms before the first token arrives, simply because the request has to cross the public internet and hit a data-center that may be thousands of miles away.
Edge inference shaves that to under 20ms: Modern GPUs, NPUs, and unified-memory CPUs can load a 7-8B-parameter model, run a forward pass, and return a token before a human blink.
Real-time experiences feel the difference: Autocomplete in a code editor, voice assistants that must respond within a conversational pause, or inline suggestions in a chat window become jitter-free when the model lives next to the user.

The result is simple: if the product promises instant feedback, the edge wins.

Cost at Scale: From Pay-Per-Token to Predictable CapEx

Pay-per-token models are a boon for prototypes: No upfront hardware, no ops overhead, and you only pay when you query.
Beyond a few hundred thousand calls, the math flips: A single-node server with a quantized model can handle the same traffic for a fraction of the cloud bill, converting volatile expenses into a fixed amortized cost.
Predictability matters: Fixed hardware spend lets finance teams forecast with confidence, a luxury rarely afforded by usage-based pricing.

Compliance: Data Never Leaves the Premises

Edge guarantees locality: Sensitive patient notes, financial transaction logs, or classified defense data stay on the device or in a secured on-prem rack. No outbound packets, no exposure to third-party storage.
Cloud contracts demand DPAs and audits: Even the most reputable providers require legal reviews of data-processing agreements, retention policies, and model-training provenance.
Regulated industries are already moving: Health-tech firms cite HIPAA, banks cite PCI-DSS, and defense contractors cite ITAR—all of which push the needle toward on-prem or air-gapped inference.

When the law draws a line, the edge draws the circle.

A Pragmatic Blueprint: Hybrid, Not Either/Or

Run lightweight, open-weight models locally: A 7-8B parameter model quantized to 4-bit precision can cover 80% of routine classification, embedding, and transformation tasks with sub-20ms latency.
Route the heavy lifting to the cloud: An asynchronous fallback service hands off the remaining 20%—complex reasoning, multi-turn dialogue, or rare domain-specific queries—to a frontier API.
Orchestrate with a smart router: Cache recent results, apply confidence thresholds, and fallback only when the local model’s uncertainty exceeds a preset limit.
Monitor and rebalance: As usage patterns evolve, shift more workloads to the edge or scale the cloud tier accordingly.

Closing Thoughts

Edge AI is no longer a niche experiment. Quantization libraries, compiler toolchains, and purpose-built silicon have matured enough to make on-device inference a cost-effective, low-latency alternative to any public API. The sweet spot is a well-engineered hybrid that moves data where it belongs and keeps the user experience razor-sharp.