How a $400 AI‑Driven Rewrite of JSONata Saved $500K in Kubernetes Costs

In a high‑throughput Go data‑pipeline, the team relied on the JavaScript implementation of JSONata for dynamic rule evaluation. This required a massive jsonata‑js Node.js service deployed on Kubernetes, leading to three major pain points:

Cost: Over 300 Pods were needed, burning about $300 K per year in compute resources.

Latency: Simple field lookups that took nanoseconds in Node.js incurred ~150 µs of RPC overhead, disastrous for billions of daily events.

Ops black‑hole: Scaling the Pod count eventually exhausted the cluster’s IP address pool.

Initial fixes such as expression optimization, caching, and embedding V8 via CGO only treated symptoms. Inspired by Cloudflare’s AI‑driven rewrite of Next.js, Nir Barak adopted a “code‑translation” approach: feed the entire jsonata‑js test suite (1,778 cases) to a large language model and command it to produce a Go implementation that passes all tests.

The three‑step plan was:

Human developers translated the test suite into Go.

All official JSONata 2.x documentation and specifications were supplied to the AI.

The AI was instructed to write Go code that passes the translated tests.

Within a weekend, the AI generated over 13,000 lines of Go code, creating the new project gnata. After seven hours of iterative generation, testing, and self‑correction, gnata passed every official test case.

The financial impact was striking: the token cost for the AI run was only $400, and the jsonata‑js cluster’s monthly cost dropped from $2.5 K to $0, saving $500 K annually after two weeks of additional refactoring.

Performance benchmarks showed dramatic gains:

Simple field lookup: 42–95 ns (Go + gnata) vs 170–230 µs (RPC), a 1,000–1,500× speedup.

Complex expression: 0.5–1.2 µs vs 160–310 µs, a 25–90× improvement.

Because gnata is pure Go, the team added a two‑layer evaluation architecture that performs zero‑heap allocations on simple lookups, invoking the full parser only for complex cases. In the following weeks they replaced another heavyweight rule engine that spawned tens of thousands of goroutines, saving an additional $200 K per year.

The rewrite also yielded organizational benefits: the PR was the first fully AI‑generated contribution, forcing reviewers to distinguish genuine concurrency bugs from cosmetic AI‑induced issues, thereby enriching the team’s AI‑assisted code‑review guidelines.

Overall, the case demonstrates that with clear test specifications and bounded scope, AI agents can perform “surgical‑scale” refactoring of production‑critical components, delivering massive cost reductions and performance improvements.