Home / Blog / Rewriting my budgeting app from PHP to Go in 3 weeks with…
Tech News

Rewriting my budgeting app from PHP to Go in 3 weeks with Claude

Econumo migrated its budgeting platform from PHP to Go in three weeks using Claude Code, reducing container image size from 1.59 GB down to 66.5 megabytes.

By Dillip Chowdary • Nov 18, 2026 • Source: kuznetsov.dev

Rewriting my budgeting app from PHP to Go in 3 weeks with Claude
Image: kuznetsov.dev

At a glance

Product
Econumo budgeting app
Versions
PHP v0.10.1 to Go v1.7.0
Tooling cost
$225 monthly subscriptions
Timeline
June 20 to July 9 beta release
Effort
60 to 90 hours across three weeks
Dependency reduction
40 direct PHP packages to 9 Go modules

Independent developer Roman Kuznetsov completed a full rewrite of Econumo, an established personal budgeting web application, replacing its PHP and Symfony backend with Go and rebuilding its Vue interface in React. As documented in kuznetsov.dev's report, the entire production stack transition concluded in three weeks using autonomous coding agents driven primarily by Anthropic's Claude Code tool.

This technical breakdown analyzes the mechanics of agent-driven software migrations, detailing how strict compiler feedback loops and reduced dependency footprints change technology selection. Engineering teams and solo developers managing legacy codebases will find actionable insights into automated test generation, contract preservation, and benchmark performance gains across real-world production environments.

01Interpreter limits and composer package sprawl

Econumo originated in 2021 as a family budgeting service assembled over two weeks using Symfony, PostgreSQL, and Vue. While the service ran stably without operational emergencies, the author stopped writing manual code across projects and shifted to directing autonomous agents. This operational change altered fundamental stack criteria, prioritizing instant compiler feedback loops and automated error detection over developer convenience and IDE ergonomics.

The interpreted nature of PHP caused problems because runtime issues bypassed type annotations and static analysis tools like PHPStan, allowing agents to miss flaws. Furthermore, the Symfony backend carried 40 direct dependencies and 107 locked Composer packages unmaintained for two years after an automated update broke authorization. Minimizing dependencies reduced the exposure to unverified agent-written code entering third-party package ecosystems.

02Go compiler speed and typed sqlc queries

Go satisfied the developer's requirements by delivering fast compilation, uniform syntax, built-in testing, and an extensive standard library handling routing, cryptography, and JSON parsing. Although Rust provided stronger memory safety, its complexity conflicted with rapid iteration. Migrating to Go condensed backend requirements from 40 direct PHP dependencies down to nine standard modules packaged in a single binary.

Organizing code into feature-based packages kept agent modifications localized, turning directory boundaries into an effective auditing mechanism when reviewing pull requests. Database interactions eliminated schema drift through sqlc, which compiles plain SQL files into typed Go code matching startup migrations. The resulting 580 named queries compile across SQLite and PostgreSQL backends, ensuring that invalid columns halt compilation before tests execute.

03Three weeks of Claude Fable model runs

The migration commenced when experiments with Anthropic's Claude Fable model demonstrated reliable code translation, prompting a full commitment to the transition. The developer dedicated 20 to 30 hours weekly between June 20 and July 9, investing roughly 60 to 90 total hours. Operational expenses were confined to monthly tooling subscriptions, specifically $200 for Claude Max 20x and $25 for OpenAI Codex, without incurring separate API usage fees.

Advertisement

Tech Pulse Daily

Get tomorrow's pulse first

Join engineers who read Tech Pulse before stand-up. Free, weekday mornings.

  1. Mechanical translation ported PHP routes, endpoints, request formats, response payloads, and database logic directly into Go to maintain behavioral parity.
  2. Test expansion ported existing suites from seven thousand PHP lines to twenty thousand Go lines while enforcing an eighty percent coverage floor.
  3. Contract freezing validated JWT signatures, password hashing, and encrypted email storage against production responses to keep client applications fully functional.
  4. Live database integration attached the compiled Go binary to existing production databases while automatically reconciling historical Doctrine schema migrations.
  5. Modular refactoring dismantled layered domain-driven design abstractions to organize business routines into self-contained feature packages.

Testing routines executed continuously across both SQLite and PostgreSQL instances to prevent agent-introduced platform regressions. The underlying backend architecture transitioned from a traditional domain-driven design model with separated controllers, services, and repositories into isolated, feature-specific modules. This encapsulation guaranteed that individual business capabilities operated autonomously while preserving seamless backward compatibility with existing client applications.

Note: Model access remained precarious throughout development because Anthropic initially announced the Claude Fable experimental window for only one or two weeks before granting extensions. The constant risk that provider access might abruptly terminate drove an aggressive three-week completion schedule before July usage quotas were exhausted.

04Frontend interface rebuild in React

Rather than mechanically porting legacy Vue code burdened by three years of technical debt, the developer instructed Claude to rebuild the user interface from scratch in React. Claude inspected live interface layouts using the Chrome Model Context Protocol integration, capturing visual snapshots to preserve original screen arrangements. The autonomous agent completed its initial pass in eight hours and totaled fifteen hours of synthesis before human review.

The developer spent three days manually validating screens and confirming workflows against unchanged backend endpoints. Selecting React reduced agent generation errors due to abundant training data, with codebase volume shifting from 21,000 lines of Vue to 19,000 lines of React. Unlike the backend, frontend dependencies grew from 20 to 38 packages due to UI toolkits like shadcn.

05Production resource drops and selective inspection

Benchmarking both runtime stacks inside Docker containers under sixteen concurrent threads revealed substantial efficiency gains across all system resources. The compiled Go container image occupied 66.5 megabytes compared to the 1.59 gigabyte PHP deployment. Under active test loads, Go stabilized memory consumption at 20 megabytes while processing 1,190 requests per second, outperforming the PHP baseline of 193 requests per second at 79 milliseconds latency.

MetricPHP v0.10.1Go v1.7.0
Docker container image1.59 GB66.5 MB
Idle memory usage57 MB14 MB
Memory under load100 MB20 MB
Throughput (16 threads)193 req/s1,190 req/s
Median request latency79 ms12 ms
Direct backend dependencies40 packages9 packages

The original Go v1.0.0 release consumed merely six megabytes at idle before subsequent feature releases added recurring transactions, mobile client integrations, and billing endpoints. Operational maintenance procedures evolved alongside the infrastructure, leading the developer to halt line-by-line frontend reviews entirely. Backend inspections now focus exclusively on package boundaries, database schema migrations, and sqlc query additions, confirming that automated tooling maintains safety without manual reading.

Frequently asked questions

How long did the Econumo backend rewrite take?

The rewrite took three weeks between June 20 and July 9, requiring roughly 60 to 90 hours of developer effort. The author worked 20 to 30 hours per week guiding autonomous agents.

How much did the tooling subscriptions cost for the migration?

The developer spent approximately $225 per month, consisting of $200 for Claude Max 20x to access Claude Fable and $25 for OpenAI Codex. No additional API fees were incurred.

How did Go performance compare to the original PHP backend?

In Docker benchmarks under 16 threads, Go v1.7.0 delivered 1,190 requests per second at 12 milliseconds latency compared to PHP v0.10.1 at 193 requests per second and 79 milliseconds. Memory usage dropped from 57 to 14 megabytes at idle.

Why did the project replace Doctrine with sqlc?

The tool sqlc turns plain SQL files into strictly typed Go code verified against startup schema migrations. This setup catches column errors and schema drift during compilation across 580 queries before tests run.

Sources

Dillip Chowdary

Author

Dillip Chowdary

Writes Tech Bytes coverage of AI, engineering, and the tools that actually ship. Editor of Tech Pulse Daily.

Related on Tech Bytes

Advertisement

5-min tech signal

Weekday briefing for engineers who skip the noise.

No spam · Unsubscribe anytime

Advertisement

✈️ CareerPilot

Your AI job-search copilot

Match your resume against live Ashby, Greenhouse & Lever openings — fit scores, job-specific resume optimization and email alerts.

Find matching jobs →

Free Tools

Browse all tools →