Bhogeshwar Jadhav

Posted on Mar 22

We Switched to Requestly for the Price. We Stayed for How It Changed Our Workflow.

#api #programming

We switched to escape a pricing trap. We stayed because it kept solving problems we'd stopped filing complaints about.

Quick context if you're joining mid-series.

In March 2026, Postman removed team collaboration from its free tier. For our four-person startup, staying meant $912 a year. We evaluated three tools over a weekend, migrated seven months of collections, and shipped the sprint on time. The first two articles cover all of that.

This one is about what happened after.

Three months in, the reasons we stay look almost nothing like the reasons we chose. The pricing was the trigger. But there's a set of features we've quietly built our workflow around — features we didn't evaluate for, didn't ask for, and in some cases didn't even know existed.

The Problem With Developer Tooling Friction

There's a particular kind of friction that never makes it into your standup.

It's the twenty minutes spent reconstructing a request you already watched fail in the network tab. The pre-request script that silently breaks because a token rotated at the wrong time. The QA bug report that says "it's broken" with a screenshot and nothing else.

You adapt. You build workarounds. You stop noticing.

What Requestly did — quietly, over three months — was remove friction we'd forgotten was friction. Feature by feature. Workflow by workflow.

No Login. Seriously, Just Open It.

Let me start with the most underrated thing Requestly does.

It does nothing. No login screen. No "create your account to continue." No SSO flow that decides to be difficult on a Monday morning. You open it, and it works.

That sounds like a footnote. It isn't.

When Postman introduced mandatory login, we complained for a day and adapted. You lose a session, you log back in, you re-authenticate. It becomes normal. You stop noticing.

Until the moment you can't afford to lose five minutes.

Three moments in the last three months alone:

Nishank on a flight — no Wi-Fi, needed to reference our payment collection before landing. Requestly opened. Everything was there. No session wall, no "you're offline" prompt.
Contractor onboarding — old process: add to workspace, wait for invite email, debug SSO. New process: clone the repo, open the folder, start working. The invite dance doesn't exist anymore.
Akshay's laptop died mid-sprint — borrowed machine, downloaded Requestly, pointed it at the repo folder, working setup in under twenty minutes. No "re-authenticate all your workspaces" loop.

None of these are dramatic. That's exactly the point. They're the small invisible moments that drain time without ever showing up in a post-mortem.

How it actually works:

Browser (app.requestly.io) — open any tab, no account needed, collections stored in browser. Works immediately, anywhere, including incognito.
Desktop app — download, open, point at a folder. Everything stored on disk. Nothing leaves your machine unless you explicitly push it.
Cloud sync — available when you need it for team collaboration. Optional, not mandatory.

The critical distinction from Postman: Postman's cloud is the requirement. Requestly's cloud is an option you reach for when you want it.

Modify Headers: The Feature We Use Every Single Day

This is Requestly's most-used feature — and after three months, we understand why.

You can inject auth tokens directly into request headers without touching your code. Add, remove, or modify Cookie headers to fake sessions or test edge cases — no browser storage changes, no code deploys.

We use it three specific ways:

Staging auth — any request to *.staging.ourapp.com gets our auth header injected automatically. Set once, never touch again. No pre-request script, no token rotation debugging.
Test personas — Priya has three header rule sets saved: admin, standard user, read-only. Switching test contexts takes seconds, no re-authenticating.
CORS during local dev — bypass CORS errors by modifying response headers locally, without touching the server. Akshay used to solve this with a proxy. Now it's a rule.

Before this, managing test personas meant keeping multiple browser profiles or a pre-request script that was always one token rotation away from silently failing.

Redirect Rule: Test Local Changes Without Deploying

This is the one that took us longest to discover and least time to become dependent on.

We load a JS bundle from our CDN in staging. Every time Akshay needed to test a local change against real staging data — real auth, real database state, real third-party integrations — the old process was: build locally, upload somewhere accessible, update the CDN reference, pray nothing broke in the upload, test, find a bug, repeat the whole cycle. On a bad day that loop ran four or five times before anything was confirmed working.

The problem was never the code. The problem was the distance between where the code lived and where it needed to run.

Now Akshay sets one rule in Requestly: any request for the staging CDN bundle gets redirected to localhost:3000/bundle.js. That's it. Real staging environment, real database state, real third-party integrations — but the JS executing is the file sitting on his machine right now, unsaved, mid-edit if he wants. No upload. No deployment. No waiting. When he's done, he disables the rule and staging goes back to the CDN bundle like nothing happened.

The first time he used it he came into standup and said "I don't know why we were doing it the other way."

We didn't have a good answer. We still don't. Some tools fix a problem. This one makes you wonder why the problem existed at all.

Local Workspace: Collections Finally Live With Your Code

All your data — collections, requests, environment variables — stays on your device. Nothing syncs anywhere unless you explicitly push it. No background uploads, no credentials sitting in infrastructure you don't control.

We pointed our Local Workspace at /apis/ inside the monorepo. Collections sit next to the code they test. When Akshay adds an endpoint, the collection update is in the same pull request as the code. Reviewers see both. API spec and test stay in sync — not because we're disciplined, but because the tool makes it the natural path.

Onboarding the contractor: cloned the repo, opened the folder, working setup before the first call ended. No invites, no sync wait, no "which environment do I use."

The Pattern Is Always the Same

Looking back, every feature followed the same pattern:

There was a problem.
We built a workaround.
The workaround had its own cost.
Eventually the cost became normal.

No login removed an invisible onboarding step.
Header rules replaced a fragile pre-request script.
Redirect rules replaced a manual deploy loop.

None of those problems were big enough to justify switching tools. But once they disappeared, we realised how much time they had quietly been costing us.

We switched to Requestly for the price. Three months later, the price isn't the story anymore.

The story is how many small problems simply stopped existing.