DEV Community: Travis Calvert

CSV Rescue: Let Local AI Do the Tedious CSV Cleanup — Without Giving It the Keys

Travis Calvert — Wed, 21 Oct 2026 22:00:01 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

CSV files are everywhere. Unfortunately, so are the little inconsistencies that make them frustrating to work with: extra whitespace, currency symbols, inconsistent date formats, missing-value placeholders, and duplicate records.

Cleaning those problems manually is tedious. Automating the process blindly can be worse.

CSV Rescue is a local-first, open-source application that uses AI to identify useful cleaning operations, lets the user approve them, and then applies the selected changes through predictable Python code.

The idea is simple: let AI figure out what might need fixing, but don't let it invent the fixes.

The workflow has three steps:

Upload a CSV file for local analysis.
Review and select recommended cleaning operations.
Preview the changes, inspect any flagged issues, and download a cleaned CSV.

The original file is never overwritten.

Demo

For the demonstration, I generated a deliberately messy 500-row CSV containing inconsistent currency and date formats, extra whitespace, missing-value markers, and duplicate records.

With five cleaning operations selected, CSV Rescue produced:

Metric	Result
Input rows	500
Output rows	475
Cell changes	739
Flagged issues	61

The application removed 25 duplicate rows while preserving ambiguous values for review.

For example, when a currency field contains unknown or TBD, CSV Rescue flags the issue instead of pretending it knows the correct amount.

The before-and-after preview also includes a change log identifying the affected row, column, operation, original value, and resulting value.

Code

GitHub:

https://github.com/BlacktopLogic/csv-rescue

The repository includes the FastAPI application, deterministic cleaning engine, CSV profiler, sample data, automated tests, setup instructions, and an MIT license.

It's designed to run locally rather than requiring a hosted application or cloud AI account.

How I Built It

CSV Rescue uses a small, intentionally straightforward stack:

Python and FastAPI for the application and browser interface.
Ollama to run AI inference locally.
Qwen3:8b as the open-weight language model.
A CSV profiling layer to summarize the uploaded data.
A deterministic cleaning engine to perform approved transformations.
pytest for automated regression testing.

The model receives a statistical profile of the CSV and recommends operations from a restricted set of supported cleaning rules.

Those operations currently include trimming whitespace, normalizing currency, normalizing dates, normalizing blank values, and removing duplicate rows.

The model does not get to generate arbitrary Python code for execution. Its suggestions are validated against supported operations, and the user chooses what to apply.

That separation is intentional. Language models are useful for recognizing patterns and suggesting actions, but data transformation needs to be predictable, inspectable, and repeatable.

Why Does Open Innovation Matter?

Local inference is central to the design.

CSV files often contain customer information, business records, or operational data that people would rather not send to an external AI service.

By using Ollama and an open-weight model, CSV Rescue can analyze a file's statistical profile on the user's own computer without requiring a cloud inference API.

This also makes the project easier to experiment with. The AI layer can evolve independently from the cleaning engine, and the core cleaning functionality doesn't depend on a paid AI subscription.

Just as importantly, open source makes the transformation logic inspectable. Users can see how their data is processed instead of having to trust an opaque AI-generated result.

The Lazy Payoff

The goal isn't to remove people from the process. It's to remove the repetitive work while keeping the important decisions.

Instead of manually inspecting hundreds of rows, searching for formatting inconsistencies, and applying spreadsheet operations one at a time, the user can review a small set of suggested rules and inspect the resulting changes.

During testing, CSV Rescue processed a 500-row sample, identified five useful operations, and produced a cleaned file with 739 cell changes.

I also tested the project from a fresh GitHub clone: installing dependencies in a new virtual environment, running all 15 regression tests successfully, launching the application, generating AI recommendations, previewing the results, and downloading the cleaned CSV.

All 15 automated tests passed.

This is an early release, not a replacement for full-featured data preparation software. But it demonstrates a useful principle: AI can take on the tedious pattern-recognition work without being given unrestricted control over the data.

Slow and steady, with a human still holding the steering wheel.

Built by Blacktop Logic.

Explore CSV Rescue on GitHub

How to Automatically Start a Cloudflare Tunnel When You Sign In to Windows

Travis Calvert — Tue, 20 Oct 2026 22:45:49 +0000

If you use Cloudflare Tunnel to expose a local development server, self-hosted application, or internal dashboard, you've probably encountered this problem:

Everything works until you restart Windows.

Your application might still be running, but the Cloudflare Tunnel process isn't. Suddenly, your public hostname is unreachable until you manually launch cloudflared again.

Here's how to automate that process using Windows Task Scheduler.

The problem

A typical Cloudflare Tunnel setup uses a command like:

cloudflared.exe tunnel run --token YOUR_TUNNEL_TOKEN

That works perfectly well in an interactive terminal.

But closing the terminal, signing out, or restarting Windows stops the process.

You can solve this by configuring Windows to launch the tunnel automatically when you sign in.

Step 1: Create a startup script

Create a PowerShell script named Start-Tunnel.ps1.

For example:

$cloudflared = "C:\Tools\cloudflared.exe"
$tokenFile = "$env:LOCALAPPDATA\CloudflareTunnel\token.txt"

if (-not (Test-Path -LiteralPath $cloudflared)) {
    throw "cloudflared.exe was not found."
}

if (-not (Test-Path -LiteralPath $tokenFile)) {
    throw "Tunnel token file was not found."
}

$token = (Get-Content -LiteralPath $tokenFile -Raw).Trim()

if ([string]::IsNullOrWhiteSpace($token)) {
    throw "Tunnel token is empty."
}

& $cloudflared tunnel run --token $token

Update the executable path to match your installation.

The script reads the tunnel token from a separate local file instead of embedding it directly in the script.

Security note: Your tunnel token is a credential. Don't commit it to GitHub, include it in screenshots, or share it in support requests. Restrict access to the token file to your Windows account.

Step 2: Configure Windows Task Scheduler

Open Task Scheduler and select Create Task.

Under General:

Give the task a descriptive name, such as Cloudflare Tunnel Startup.
Select Run only when user is logged on.
Use your normal Windows account.

Under Triggers:

Create a trigger that runs At log on.
Select your Windows account.

Under Actions, create a new action:

Program/script:

powershell.exe

Add arguments:

-NoProfile -NonInteractive -ExecutionPolicy Bypass -File "C:\Scripts\Start-Tunnel.ps1"

Replace the script path with your actual location.

Under Settings, review the options that control whether the task can start again while an existing instance is running.

Save the task.

Step 3: Test it

Right-click the task and select Run.

Check Task Manager for the cloudflared.exe process.

Then verify that your public hostname actually reaches your local application.

A running process alone doesn't prove the tunnel is connected successfully.

Finally, sign out and sign back in to confirm that the task launches automatically.

What about running the tunnel before login?

A sign-in task starts only after the specified user logs on.

If you need the tunnel to be available immediately after Windows boots, before anyone signs in, you'll need a different approach, such as a properly configured Windows service.

That distinction matters for unattended servers.

Where this basic approach gets complicated

Task Scheduler handles the initial launch, but a production-quality setup involves more than just running a PowerShell script.

You may also want:

Protection against duplicate launchers
A predictable way to stop the tunnel
Logging for troubleshooting
Secure token storage
Clean installation and removal
Reliable cleanup of child processes

These details can take longer to get right than the initial scheduled task.

A ready-made alternative

I built Cloudflare Tunnel Auto-Start Kit for Windows under Blacktop Logic to package the Windows sign-in approach into a reusable toolkit.

It includes PowerShell installation, startup, status, and uninstall scripts, along with process management and logging.

It is designed for user sign-in startup, not as a replacement for a Windows service.

The kit is available as a one-time $19 purchase:

https://payhip.com/b/FnwaJ

If you're comfortable maintaining your own scheduled task, the manual approach above may be all you need.

If you'd rather avoid building and troubleshooting the supporting scripts yourself, the kit is another option.

Published by Blacktop Logic — practical software utilities for developers and self-hosters.