Building a Data API on Zero Budget: A Retrospective on 100% AI-Generated Code

An independent developer built a data API platform with cryptographic integrity verification using code entirely generated by AI, on a budget of zero. What's worth paying attention to here isn't just the "zero cost" — it's the emerging new development paradigm it demonstrates: when AI handles all the coding work, the human role shifts from "writing code" to "designing architecture."

What He Actually Built

The project is called Alrithm API, positioned as a platform for accessing "verified data" with the goal of plugging clean, structured datasets directly into AI training pipelines or data processing workflows. The developer describes himself as a solo operation with zero balance in both his bank account and his MetaMask wallet. All code, backend architecture, and database schemas were generated by AI under human architectural guidance.

It aims to solve a genuinely painful problem: when training machine learning models, data cleaning is an unavoidable nightmare. Platforms like Scale AI exist, but they serve enterprise budgets, effectively excluding independent researchers and individual developers. More critically, most datasets online are just static files with no built-in mechanism to prove that data hasn't been tampered with or corrupted during transmission.

Alrithm API attempts to provide a plug-and-play API that delivers both clean data and integrity guarantees.

Core Technology: Row-Level Merkle Root Verification

The platform is hosted on Vercel to keep costs at zero. Unlike ordinary APIs that just return JSON, the core design of this system embeds cryptographic verification into the data engineering layer.

Specifically, the system hashes the data schema and embeds a Merkle Root verification into every row of data. If even a single byte is corrupted or tampered with during transmission, the cryptographic proof breaks immediately. Data engineers can verify in real time whether an entire data source is intact. This "row-level" granularity means verification isn't a one-time check on the whole dataset — every row is independently traceable.

Another design decision is Web3 integration: the platform natively supports MetaMask wallets, laying groundwork for future decentralized data contributors and Web3 fundraising, deliberately bypassing the traditional banking system.

From a technical standpoint, grafting Merkle proofs — a mature cryptographic tool from the Ethereum ecosystem — onto row-level validation for an ordinary data API is a pragmatic cross-disciplinary approach. It won't suit every scenario — for instance, latency-sensitive high-frequency data streams would incur extra overhead from row-by-row verification — but for AI training datasets that prioritize auditability, this trade-off is reasonable.

What Are Merkle Trees and Merkle Roots

A Merkle tree is a hash binary tree proposed by Ralph Merkle in 1979. It's constructed by pairing data blocks and hashing them, then pairing and hashing the results, layer by layer upward until only a single root hash remains — that root is the Merkle Root. Its key property is that any change to a single leaf of data propagates up the path, altering every hash above it and ultimately producing a completely different root hash.

This gives rise to two engineering properties of enormous value. First, efficient verification: to prove that a particular row of data belongs to a dataset, you only need to provide the sibling node hashes along the path from that row to the root (a Merkle Proof), with verification costing O(log n) — no need to download the full dataset. Second, tamper detection: as long as the root hash is credibly anchored, no byte-level modification can slip through.

Merkle trees are foundational infrastructure in Git, IPFS, Bitcoin, and Ethereum (Ethereum's state root and transaction root are both Merkle Patricia tries). Using them for row-level validation in a data API is essentially migrating the integrity proof mechanism from the blockchain world to ordinary data distribution scenarios.

The Role of Web3 Wallets and MetaMask in Non-Crypto Projects

MetaMask is the most widely used browser wallet and signing tool in the Ethereum ecosystem. Its core capability is managing private keys and cryptographically signing transactions or messages, allowing users to prove identity and ownership without relying on a centralized account system.

For a data platform like Alrithm API, MetaMask integration brings at least three layers of value. First is the identity layer: wallet addresses replace email-plus-password systems, inherently decentralized, with no need to build an authentication database. Second is the payment and incentive layer: tokens can be issued to reward data contributors, or on-chain payments can replace traditional subscriptions. Third is the trusted anchoring layer: the Merkle Root itself can be written into on-chain contracts, leveraging blockchain immutability to provide external endorsement for data integrity.

This also explains what the original article means by "deliberately bypassing the traditional banking system" — with zero budget and no corporate entity, a Web3 wallet is the only financial and identity infrastructure that can be activated immediately without approval.

What Happens to Your Workflow When AI Writes All the Code

The experience the developer shared may be the most valuable part of the entire article. When 100% of the code is generated by AI, the nature of your work fundamentally changes: you're no longer the person writing code line by line — you're the system architect.

He mentions spending enormous amounts of time refining prompts, reviewing data schemas, and catching edge cases. The hardest part isn't getting AI to write code — it's keeping the system modular, sufficiently optimized, and running smoothly on serverless infrastructure without crashing. This point captures a core challenge of AI programming: AI excels at generating locally functional code snippets, but maintaining global architectural consistency, controlling complexity, and ensuring the system runs stably under real-world constraints still depends heavily on human judgment.

This also explains why "100% AI-generated code" and "launching a production system at zero cost" can both be true simultaneously — precisely because the toolchain (Vercel's serverless hosting) and the generation tool (AI) both eliminate the fixed costs of traditional development.

How Serverless Architecture Amplifies and Constrains AI-Generated Code

Serverless means developers don't need to manage servers — code executes on demand as functions with per-invocation billing. Typical examples include Vercel Functions, AWS Lambda, and Cloudflare Workers. Its advantage is eliminating idle costs, enabling zero-budget projects to reach production.

But it imposes strict constraints on code shape, which is precisely why the original article emphasizes "keeping it modular and not crashing on serverless." First is cold start: functions that haven't been called for a while take longer on first execution, and the heavier the initialization logic, the more pronounced this becomes. Second is statelessness: function instances can be destroyed at any time, so you can't rely on in-process caching or local files — all state must be externalized to a database or object storage. Third is execution time and memory limits: row-by-row Merkle verification written as a single full-table traversal can easily trigger timeouts or memory overflow, so it must be split into parallelizable batch units. Fourth is concurrency and connection pooling: database connections can easily get overwhelmed when functions spin up densely, requiring connection proxies.

Therefore, even if AI-generated code is logically correct, it must undergo serverless-oriented refactoring before it's production-ready — and that judgment call is still largely made by humans.

What This Really Means

Viewing this project against a broader backdrop, it demonstrates at least two things.

First, AI-assisted development is lowering the barrier from "idea to runnable product" to unprecedented levels. Zero budget, solo developer, first release — yet delivering a backend system with cryptographic verification was almost unimaginable just a few years ago.

Second, a new division of labor is taking shape. Human value is no longer measured by whether you can hand-write a particular algorithm or debug a piece of code — it's measured by whether you can design sound system architecture, define clear interfaces, and identify edge-case vulnerabilities in AI-generated code. This is an "architect + reviewer" role that actually demands higher-level systems thinking.

The platform is still in its early stages — this is a first release — and the developer himself is inviting the community to test the API, review the data structures, and provide feedback. Whether it can truly solve the problem of scaling data integrity verification remains to be tested by real users. But the path it demonstrates — zero budget, full-stack AI generation, cryptographic verification embedded in the data layer — is worth a serious look for anyone paying attention to AI programming and independent development.

One-line Summary

An independent developer built a data API platform with row-level Merkle verification using 100% AI-generated code on zero budget.

Paragraph Summary

A solo developer on zero budget built Alrithm API — a platform delivering verifiable clean data for AI training pipelines — entirely with AI-generated code, hosted on Vercel. Its technical core embeds Merkle Root verification into every row of data, so any tampered or corrupted byte breaks the cryptographic proof, enabling real-time, traceable integrity checks, with native MetaMask integration laying groundwork for Web3 data contribution and decentralized fundraising. The developer notes that when AI handles all coding, the human role shifts from writing code line by line to serving as system architect — the real difficulty lies in refining prompts, reviewing schemas, catching edge cases, and keeping the system modular and stable in a serverless environment. This case shows how AI programming is dramatically lowering the barrier from idea to shipped product while reshaping developers' core competencies.