I moved the backend of Currency Converter Board from FastAPI on Railway to Hono on Cloudflare Workers.
This post covers:
- Why I moved from Railway to Workers (cost, speed, operations)
- Why I passed on the D1 + PyWrangler plan I first considered
- The actual steps I took to migrate to Hono
I hope it helps anyone who wants to move a personal-project API to the edge or cut fixed costs.
Why I Moved
The reasons are simple: perceived speed, cost, and the fact that I wanted to use Hono.
I was on Railway’s Hobby plan, at roughly $5 a month.
The amount itself isn’t big, but it’s a fixed cost even in months with little usage.

This service started as a personal project for learning, and I want to keep running costs as low as possible.
Paying a fixed fee while the user count is still small honestly nagged at me.
On top of that, responses weren’t exactly “blazing fast,” so it was a weak reason to keep paying.
Meanwhile, the frontend was already running on Cloudflare, so moving the backend into the same ecosystem would simplify the setup.
That’s what pushed me to migrate to Workers.
Architecture Before the Migration
- Frontend: Served from Cloudflare
- Backend (Railway): FastAPI, handling:
- Database (user management, history, and other records)
- Anything to do with the Wise API
- Google login (OAuth and other auth flows)
What I moved this time is this backend. I didn’t change where the frontend is deployed.
My First Idea: A Worker with D1 and PyWrangler
At first I considered using Cloudflare D1 as the DB and running a Python Worker with PyWrangler.
PyWrangler lets you run Python on Workers, and since my existing backend was Python, it was a strong candidate.
But when I actually tried it (it was in beta at the time), startup and responses felt heavy.
Assuming I’d run on the free tier, I decided it wouldn’t work this time.
So I dropped the PyWrangler plan and switched to building the API with Hono + Workers (TypeScript).
What I Actually Went With: Hono on Workers
In the end, I rebuilt the API with Hono and deployed it to Cloudflare Workers.
I moved the logic from FastAPI (Python) to TypeScript, porting authentication, external APIs, and DB access one by one.
The Migration Flow (Roughly)
For the actual work, I first pinned down a migration plan with Claude and Cursor, then went ahead.
Since the scale wasn’t large, the migration itself finished in a day.
- Take inventory of the FastAPI setup on Railway (endpoints, DB schema, environment variables, external dependencies)
- Create a Workers project and set up equivalent routes in Hono
- Reimplement the Wise API, Google OAuth, and DB for the Workers execution model
- Hit the new API from the frontend locally to check that it works
- Switch the production API target over gradually
- Stop the Railway resources and confirm billing has stopped
Where I Got Stuck (Notes)
There wasn’t anything I got badly stuck on.
If anything, when working with AI, it was important to do the initial migration plan (taking inventory of specs) carefully.
This time the scale was small, so reviewing and testing the generated implementation and then deploying it myself went smoothly.
On the technical side, I couldn’t export the Railway DB data cleanly, so moving some of it into D1 by hand was a bit of a chore.
Summary
- Moving to Hono + Workers improved the balance of perceived speed and running cost.
- Consolidating the frontend and backend on Cloudflare also simplified the setup and operations.
- For personal projects where you want to run mainly on the free tier at first, I think it’s an option worth trying.
Related Posts
- The service itself: I Built Currency Converter Board