DEV Community: Travis Calvert

How to Automatically Start FastAPI When You Sign In to Windows 10 or 11

Travis Calvert — Sat, 24 Oct 2026 16:16:30 +0000

If you're developing or running a FastAPI application on Windows, manually opening a terminal and starting Uvicorn every time you sign in gets old quickly.

Windows Task Scheduler provides a built-in way to launch your application automatically when you log in—without turning it into a Windows service.

Windows sign-in startup vs. a Windows service

These are two different approaches:

Task Scheduler at sign-in: Starts your FastAPI application after you sign in to your Windows account.
Windows service: Can run independently of an interactive user session, including before anyone signs in.

If you're running a local development tool, personal dashboard, or an application you use during your Windows session, Task Scheduler may be sufficient.

If you need an unattended production server, a properly configured Windows service or another dedicated deployment environment may be more appropriate.

Option 1: Configure FastAPI startup manually

Suppose your project lives in:

C:\Projects\my-fastapi-app

And your virtual environment is located at:

C:\Projects\my-fastapi-app\.venv

First, verify that your application starts normally:

cd C:\Projects\my-fastapi-app
.\.venv\Scripts\python.exe -m uvicorn main:app --host 127.0.0.1 --port 8000

Replace main:app with your actual application import path.

Once that works:

Open Task Scheduler.
Select Create Task.
Name the task FastAPI Startup.
Under Triggers, select At log on for your Windows account.
Under Actions, select Start a program.
Set Program/script to C:\Projects\my-fastapi-app\.venv\Scripts\python.exe.
Set Add arguments to -m uvicorn main:app --host 127.0.0.1 --port 8000.
Set Start in to C:\Projects\my-fastapi-app.
Save the task and test it using Run in Task Scheduler.

You should now be able to visit:

http://127.0.0.1:8000/docs

If your application exposes FastAPI's default documentation endpoint, it should be available while Uvicorn is running.

Common problems

The task runs but FastAPI doesn't respond

Check the Python executable path, project working directory, application import path, and whether the expected port is available.

It works in a terminal but fails in Task Scheduler

Your application may rely on environment variables, relative file paths, or an activated virtual environment. Using the virtual environment's Python executable directly and setting the working directory can eliminate some of these problems.

Multiple copies of Uvicorn are running

Check whether you've launched the application manually in addition to the scheduled task. Review the task's settings for handling an instance that is already running.

You need the application running before sign-in

A logon-triggered task is not the right solution for that requirement. Consider a service-based deployment instead.

Option 2: Use a packaged automation kit

The manual Task Scheduler approach is free and may be all you need.

For developers who would rather avoid assembling and managing the startup configuration themselves, Blacktop Logic's FastAPI Auto-Start Kit for Windows is a $19 toolkit designed to launch an existing FastAPI application when you sign in.

The product advertises Windows Task Scheduler integration, process management, duplicate-instance prevention, graceful shutdown, and a simplified setup process.

It's intended for Windows 10 and 11 sign-in workflows—not as a replacement for an unattended production Windows service.

Learn more: FastAPI Auto-Start Kit for Windows

Final thoughts

You don't need to install extra software just to start FastAPI when you sign in to Windows. Task Scheduler can handle the basic job.

The decision is whether you'd prefer to configure and maintain the workflow yourself or use a packaged toolkit that handles more of the setup and process management.

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.