Discussion

We Rewrote JSONata with AI in a Day, Saved $500K/Year | Reco

captn3m0: For context, JSONata's reference implementation is 5.5k lines of javascript.

whalesalad: > The reference implementation is JavaScript, whereas our pipeline is in Go. So for years we’ve been running a fleet of jsonata-js pods on Kubernetes - Node.js processes that our Go services call over RPC.> This was costing us ~$300K/year in computeWooof. As soon as that kind of spend hit my radar for this sort of service I would have given my most autistic and senior engineer a private office and the sole task of eliminating this from the stack.At any point did anyone step back and ask if jsonata was the right tool in the first place? I cannot make any judgements here without seeing real world examples of the rules themselves and the ways that they are leveraged. Is this policy language intentionally JSON for portability with other systems, or for editing by end users?My first thought would have been a compiler that turns JSONata expression into literal golang function, so there is no DSL/runtime/parser in the critical path.

ebb_earl_co: > This was costing us ~$300K/year in compute, and the number kept growing as more customers and detection rules were added.Maybe I’m out of touch, but I cannot fathom this level of cost for custom lambda functions operating on JSON objects.

slopinthebag: It has to be satire right? Like, you aren't out of touch on this. I get engineers maybe making the argument that $300k / year on cloud is the same as 1.5 devops engineers managing in-house solutions, but for just json parsing????

TZubiri: As long as you are using JSON, you will be able to optimize.Did you know that you can pass numbers up to 2 billion in 4 constant bytes instead of as a string of 20 average dynamic bytes? Also, fun fact, you can cut your packets in half by not repeating the names of your variables in every packet, you can instead use a positional system where cardinality represents the type of the variable.And you can do all of this with pre AI technology!Neat trick huh?

cosmotic: Next maybe they will use a binary format instead of JSON.

cjonas: The docs indicate there are already 2 other go implementations. Why not just use one of those? https://docs.jsonata.org/overview.html

kace91: >The approach was the same as Cloudflare’s vinext rewrite: port the official jsonata-js test suite to Go, then implement the evaluator until every test passes.the first question that comes to mind is: who takes care of this now?You had a dependency with an open source project. now your translated copy (fork?) is yours to maintain, 13k lines of go. how do you make sure it stays updated? Is this maintainance factored in?I know nothing about JSONata or the problem it solves, but I took a look at the repo and there's 15PRs and 150 open issues.

simonw: That's only important if the plan is to stay feature-compatible with the original going forward.For this case, where it's used as an internal filtering engine, I expect the goal is fixing bugs that show up and occasionally adding a feature that's needed by this organization.

kace91: >expect the goal is fixing bugs that show up and occasionally adding a feature that's needed by this organization.Even if we assume a clean and bug free port, and no compatibility,and a scope that doesn't involve security office risks, that's already non trivial, since it's a codebase no one has context of.Probably not 500k worth of maintainance (because wtf were they doing in the first place) but I don't buy placing the current cost at 0.

Herring: The full translation took 7hrs and $400 in tokens. Applying diffs every quarter using AI is much easier and cheaper.Software engineering has completely changed.

aniceperson: except there are 2 go implementations already, and he burnt 500k per year to have a kubernetes clusters to parse json (???), so the total gain is -500000*year - 400 + 1 (deducting prompt to use existing implementation)

Aurornis: The key point for me was not the rewrite in Go or even the use of AI, it was that they started with this architecture:> The reference implementation is JavaScript, whereas our pipeline is in Go. So for years we’ve been running a fleet of jsonata-js pods on Kubernetes - Node.js processes that our Go services call over RPC. That meant that for every event (and expression) we had to serialize, send over the network, evaluate, serialize the result, and finally send it back.> This was costing us ~$300K/year in compute, and the number kept growing as more customers and detection rules were added.For something so core to the business, I'm baffled that they let it get to the point where it was costing $300K per year.The fact that this only took $400 of Claude tokens to completely rewrite makes it even more baffling. I can make $400 of Claude tokens disappear quickly in a large codebase. If they rewrote the entire thing with $400 of Claude tokens it couldn't have been that big. Within the range of something that engineers could have easily migrated by hand in a reasonable time. Those same engineers will have to review and understand all of the AI-generated code now and then improve it, which will take time too.I don't know what to think. These blog articles are supposed to be a showcase of engineering expertise, but bragging about having AI vibecode a replacement for a critical part of your system that was improperly designed and costing as much as a fully-loaded FTE per year raises a lot of other questions.

hansvm: I mostly agree, but it's more appropriate to weigh contributions against an FTE's output rather than their input. If I have a $10m/yr feature I'm fleshing out now and a few more lined up afterward, it's often not worth the time to properly handle any minor $300k/yr boondoggle. It's only worth comparing to an FTE's fully loaded cost when you're actually able to hire to fix it, and that's trickier since it takes time away from the core team producing those actually valuable features and tends to result in slower progress from large-team overhead even after onboarding.

otterley: They said in the article that they were running up to 200 pods at a time. Doing some back of the envelope math, 200 pods at $300,000 year is about $0.17/hour, which is exactly what an EC2 c5.xlarge costs per hour (on demand). That has 4 vCPUs, so about 800 vCPUs during peak, with $0.0425/CPU-hour.I do have some questions like:* Did they estimate cost savings based on peak capacity, as though it were running 24x7x365?* Did they use auto scaling to keep costs low?* Were they wasting capacity by running a single-threaded app (Node-based) on multi-CPU hardware? (My guess is no, but anything is possible)

shimman: This case looks like pure marketing fluff rather than sound engineering tho.

hobofan: > If they rewrote the entire thing with $400 of Claude tokens it couldn't have been that big.The original is ~10k lines of JS + a few hundred for a test harness. You can probably oneshot this with a $20/month Codex subscription and not even use up your daily allowance.

cogogo: Think this is pure piggyback marketing on what cloudflare did with next.js. In my experience a company that raised $30MM a month ago is extremely unlikely to be investing energy in cost rationalization/optimization.edit: saw the total raise not the incremental 30MM

saadn92: > the first question that comes to mind is: who takes care of this now?probably another AI agent at their company, who I'm sure won't make any mistakes

bawolff: I'm just kind of confused what took them so long. So it was costing 300k a year, plus causing deployment headaches, etc.But its a realitively simple tool from the looks of it. It seems like their are many competitors, some already written in go.Its kind of weird why they waited so long to do this. Why even need AI? This looks like the sort of thing you could port by hand in less than a week (possibly even in a day).

kjuulh: Not saying it is a good thing, but an organization, especially if there has been a lot of turnover, can enter a state of status quo.> it must have that architecture for a reason, we don't enough knowledge about it to touch it, etc.That or they simply haven't had the time, cost can creep up over time. 300k is a lot though. Especially for just 200 replicas.Seems wildly in-efficient. I also don't understand why you wouldn't just bundle these with the application in question. Have the go service and nodejs service in the same pod / container. It can even use sockets, it should be pretty much instant (sub ms) for rpc between them.

encoderer: I wonder if you've ever worked on a web service at scale. JSON serialization and deserialization is notoriously expensive.

slopinthebag: Would it be better or worse if I had that experience and still said it's stupid?

encoderer: You didn't say it was stupid. If you had, I would have just ignored the comment. But you expressed a level of surprised that led me to believe you're unfamiliar with how much of a pain in the ass JSON parsing is.

pravetz259: Congrats! This author found a sub-optimal microservice and replaced it with inline code. This is the bread and butter work of good engineering. This is also part of the reason that microservices are dangerous.The bad engineering part is writing your own replacement for something that already exists. As other commenters here have noted, there were already two separate implementations of JSONata in Go. Why spend $400 to have Claude rewrite something when you can just use an already existing, already supported library?

aniceperson: Because his prompt said to implement in go, not to check if an go implementation already exists. They have been running kubernetes clusters to parse json, this is not suprising.

ipsum2: Everyone is surprised at the $300k/year figure, but that seems on the low end. My previous work place spends tens of millions a year on GPU continuous integration tests.

Aurornis: The $300K/year figure is surprising because it was for something that didn't need to exist (RPC calls).

mickael-kerjean: A principal engineer spending his week end vibe coding some slop at a rate of 13k lines of code in 7h to replace a vendor. Is this really the new direction we want to set for our industry? For the first time ever, I have had a CTO vibe conding something to replace my product [1] even though it cost less than a day of his salary. The direction we are heading makes me want to quit, all points to software now being worthless[1] https://github.com/mickael-kerjean/filestash

jujube3: Stop reading ahead.

bawolff: They got a 1000x speed up just by switching languages.I highly doubt the issue was serialization latency, unless they were doing something stupid like reserializing the same payload over and over again.

encoderer: Well, for starters, they replace the RPC call with an in-process function call. But my point is anybody who's surprised that working with JSON at scale is expensive (because hey it's just JSON!) shouldn't be surprised.

bawolff: Well everything is expensive at scale, and any deserialization/serialization step is going to be expensive if you do it enough. However yes i would be surprised. JSON parsing is pretty optimized now, i suspect most "json parsing at scale is expensive" is really the fault of other parts of the stack

zellyn: If you can incorporate Quamina or similar logic in there, you might be able to save even more… worth looking into, at least

sublinear: These articles remind me so much of those old internet debates about "teleportation" and consciousness.Your physical form is destructively read into data, sent via radio signal, and reconstructed on the other end. Is it still you? Did you teleport, or did you die in the fancy paper shredder/fax machine?If vibe code is never fully reviewed and edited, then it's not "alive" and effectively zombie code?

amazingamazing: how many billions of compute are wasted because this industry can't align on some binary format across all languages and APIs and instead keep serializing and deserializing things

kanbankaren: ASN.1 and its on the wire format BER and DER have been available for close to 30+ years and it is running on billions of devices(cryptography, SSL, etc) and other critical infrastructures.but, it is very boring stable, which means I can't tell the world about my wartime stories and write a blog about it.

Aurornis: They were running a big kubernetes infrastructure to handle all of these RPC calls.That takes a lot of engineer hours to set up and maintain. This architecture didn't just happen, it took a lot of FTE hours to get it working and keep it that way.

hansvm: Yeah, the situation from TFA doesn't make a lot of sense; I was just highlighting that it's not as clear-cut as "costs >1 FTE => fix it."

VladVladikoff: This isn’t the first time I’ve read a ridiculous story like this on hackernews. It seems to be a symptom of startups who suddenly get a cash injection with no clue how to properly manage it. I have been slowly scaling a product over the past 12 years, on income alone, so I guess I see things differently, but I could never allow such a ridiculous spend on something so trivial reach even 1% of this level before squashing it.

whalesalad: JSON is not really the core issue which is the expression parser. "user.name = foo and user.id > 1000". Even if you were operating on binary data, turning an arbitrary pseudocode string into actual function logic + executing it would be the slow part.

xp84: For numbers like that, I can never tell whether it's just a vastly larger-scale dataset than any that I've seen as a non-FAANG engineer, OR, a hilariously-wasteful application of "mAnAgEd cLoUd sErViCeS" to a job that I could do on a $200/month EC2 instance with one sinatra app running per core. This is a made-up comparison of course, not a specific claim. But I've definitely run little $40 k8s clusters that replaced $800/month paid services and never even hit 60% CPU.

ebb_earl_co: Right, this is roughly my mental situation, too. I guess that streaming JSON things can eat up compute way faster than I had any intuition for!

felixagentai: The most interesting thing about AI rewrite stories isn't the time saved — it's the forcing function. Someone had to articulate what the system actually does clearly enough for an AI to replicate it. That clarity exercise alone often reveals the architectural problems that caused the cost bloat.The $500K/year wasn't from JSONata being expensive. It was from an architecture that serialized, sent over the network, and deserialized for every expression evaluation. An engineer documenting that flow for any reason — AI rewrite or not — would likely have spotted the problem.

ebb_earl_co: This is a helpful breakdown, thanks, @otterley.It is, by orders of magnitude, larger than any deployment that I have been a part of in my work experience, as a 10-year data scientist/Python developer.

jgalt212: These "solutions" place a lot of faith in a "complete" set of test cases. I'm not saying don't do this, but I'd feel more comfortable doing this plus hand-generating a bunch of property tests. And then generating code until all pass. Even better, maybe Claude can generate some / most of the property tests by reading the standard test suite.

comrade1234: So they used an ai trained on the original source code to "rewrite" the original source code.

delijati: it is all yolo from here on out ... every major ai decision we're making today feels like a bet that agi will eventually show up and clean up the mess

52-6F-62: There is a choice, yet.

The approach was the same as Cloudflare’s vinext rewrite: port the official jsonata-js test suite to Go, then implement the evaluator until every test passes.

crazygringo: > The approach was the same as Cloudflare’s vinext rewrite: port the official jsonata-js test suite to Go, then implement the evaluator until every test passes.This makes me wonder, for reimplementation projects like this that aren't lucky enough to have super-extensive test suites, how good are LLM's at taking existing code bases and writing tests for every single piece of logic, every code path? So that you can then do a "cleanish-room" reimplementation in a different language (or even same language) using these tests?Obviously the easy part is getting the LLM's to write lots of tests, which is then trivial to iterate until they all pass on the original code. The hard parts are how to verify that the tests cover all possible code paths and edge cases, and how to reliably trigger certain internal code paths.

jng: I've found Claude Code with Opus 4.5+ to be excellent at generating test cases that exercise the different features, and even push into the edge cases. You sometimes need to nudge it into generating more convoluted cases when necessary, but then it is just nudging. I now routinely generate more LOCs of test cases than actual core code, while I used to only write very limited test cases just for the most complex areas amenable to automated testing.I've been successful at using Claude Code this way:1. get it to generate code for complex data structures in a separate library project2. use the code inside a complex existing project (no LLM here)3. then find a bug in the project, with some fuzzy clues as to causes4. tell CC about the bug and ask it to generate intensive test cases in the direction of the fuzzy clues5. get the test cases to reproduce the bug and then CC to fix it by itself6. take the new code back to the full project and see the issue fixedAll this using C++. I've been a pretty intensive developer for ~35 years. I've done this kind of thing by hand a million times, not any more. We really live in the future now.