Build log

    We tested our rate limiter with 33 requests. Zero were blocked.

    A limiter that exists is not a limiter that works. What we found when we tested ours, how we fixed it, and why we publish it.

    GC
    GarunaCDX Editorial
    Editorial team
    Oct 19, 2026 2 min read
    Key takeaways
    • A safeguard in the code can still do nothing. Test it by pushing past the limit.
    • Memory inside a short-lived function is not shared state.
    • We found this before real users, on a demo clinic. It is fixed, not yet measured under load.
    • We list our own faults because it is the honest answer to 'what did your last audit find?'

    Quick answer

    On a clinic-queue platform we built, the first rate limiter kept its count in memory and blocked nothing: 13 requests in sequence and 20 in parallel, none refused. We moved the counter into the database and a live test then showed requests being refused. We found it because we tested the limiter itself.

    What happened

    We built a rate limiter to stop one caller flooding the platform. It was in the code. It looked right. So we tested it: 13 requests one after another, then 20 at once. Zero were blocked.

    Why

    The count lived in the memory of the function handling each request. Functions like these don’t reliably share memory between requests, so every request saw a fresh count. The limit was never reached because nothing remembered the last request.

    The fix

    We moved the counter into the database, where every request sees the same number. We then repeated the test against the live setup. Requests were refused once the limit was reached.

    What this does and doesn’t show

    Proof · grade 4 · our own build for an independent client

    Built and tested on a demo clinic ahead of launch. The fix works in that test. We have not measured it under real load, and we don’t publish the limit or settings.

    It shows that we test safeguards, not only features, and that testing found a defect that reading the code did not. It does not show that the platform is secure. A rate limiter is one control among many, and we do not use “secure” as a blanket claim.

    Why we publish this

    When you vet a vendor, one good question is: what did your last audit find, and what is still open? This is part of our answer. The full checklist is here, and here is how to test before real users arrive.

    Pre-launch review
    Send us the safeguards in your system. We'll tell you which ones to test first.
    Book a review

    The numbers come from our own test notes for the clinic-queue platform and are tracked in our claim ledger. No figure comes from a third party.

    Your verdict
    Was this article useful?
    GC
    Written by
    GarunaCDX Editorial
    Editorial team

    Engineers, product and growth folks at GarunaCDX writing about the systems we build for clients.

    View all articles
    Share
    Stay current

    Get GarunaCDX news in your inbox.

    Launches, new case studies and the industry shifts we are watching — once a month.

    Subscribe free
    FAQ

    Frequently asked questions

    The count lived in the memory of the function handling each request. Functions like this don't reliably share memory between requests, so each request saw a fresh count and nothing reached the limit.

    We sent traffic past the limit, first one request after another and then in parallel, and checked whether any were refused. None were.

    The counter now lives in the database, so every request sees the same count. A live test then showed requests being refused past the limit.

    The GarunaCDX build log

    Industry insights, once a month

    New case studies, healthcare, marketplace, B2B SaaS and industrial breakdowns, and the engineering notes behind what we ship. One short email a month, no fluff.

    We never share your data — see our Privacy Policy for details.