Forem: Bhogeshwar Jadhav

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

Bhogeshwar Jadhav — Sun, 22 Mar 2026 13:43:46 +0000

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.

We Migrated from Postman to Requestly — Here’s What Actually Happened

Bhogeshwar Jadhav — Tue, 17 Mar 2026 07:59:45 +0000

Picking the Tool Took a Weekend. Proving We Hadn’t Broken Anything Took Two Weeks.

If you read the first piece, you know the context. In March 2026, Postman removed collaborative workspaces from the free tier. For our four-person team, staying meant ~$912/year.

So we evaluated alternatives and chose Requestly.

We chose Requestly for three reasons — all of which mattered more after the first week:

It does something the others don’t

It intercepts live traffic from your running app. Priya could watch real requests, modify them, and save them directly into a collection.

That replaced an entire debugging loop.

Git-backed sync matched how we already work

Code, docs, infra — everything lives in GitHub.

Postman was the only thing sitting outside that system.

Requestly pulled it back in.

Team features without a paywall

The combination of open source + real collaboration + $0 cost wasn’t matched anywhere else we looked.

The Part That Actually Matters: Import

Tools are easy to pick.

Migrations are where things break.

We weren’t moving a demo setup. We had:

6 collections
4 environments
OAuth + token refresh logic
Webhooks reverse-engineered from bad docs
Months of test scripts

We treated this like a production change and wrote a checklist before importing:

Migration Checklist

Structure (folders, nesting)
Environments + variables
Auth configs
Pre-request + test scripts
Request bodies (especially multipart)

Exporting from Postman

Before importing anything, we exported our existing collections in the most compatible format.

Steps:

Open your collection
Click the ••• (three dots) menu
Select Export
Download the JSON file

Importing into Requestly

Steps:

Open Requestly
Go to Collections
Click Import (or drag and drop the file)
Click Postman collections and Environments
Select the exported JSON
Open the imported collection

Within a few seconds, the entire structure appeared:

All collections
Nested folders
Requests and endpoints

No manual setup required.

What Worked

Exported from Postman (v2.1) → imported into Requestly.

Structure: intact, including deep nesting
Environments: all correct
Auth: Bearer, API key, OAuth — all worked
Request bodies: clean across formats

No reconfiguration needed.

That’s rare.

What Broke

Our auth flow depends on a collection-level pre-request script (~40 lines).

It imported fine.

It didn’t run correctly.

pm.sendRequest() behaves slightly differently, and the error callback failed silently.

Result:

Tokens didn’t refresh
Requests returned 401
Looked like a backend issue

Fix

5 lines changed
Time to find: 15 minutes

The dangerous bugs aren’t big — they’re the ones that look unrelated.

If you use collection-level scripts, test them separately.

The Git Sync Adjustment

This was the uncomfortable part.

Week 1: Merge conflicts. Friction. Regret.

Week 2: It clicked.

API changes showed up in pull requests
New devs got full setup by cloning the repo
No invites, no workspace access issues

What felt wrong early became the most useful part later.

What It Cost

Not money — time.

Evaluation: about half a day (~12 hours across the team)
Import and initial testing: ~2 hours
Debugging the script issue: another ~2 hours
Adjusting to the new workflow: about a week of small frictions

All in, the migration took roughly 8–10 hours of focused work, plus a week to feel natural.

Saved: ~$912/year

New cost: $0

If You’re Doing This

Export in v2.1
Write your checklist before starting
Test scripts explicitly
Give Git sync 2 weeks, not 2 days

Where We Landed

Migration done. No major breakage.

The real signal:

Priya hasn’t complained once.

That’s usually how we know something actually works.

Next: Three months later — what held up, what didn’t, and what we’d change.

References

Postman Just Killed Our Free Workspace Mid-MVP. Here’s What We’re Doing About It.

Bhogeshwar Jadhav — Thu, 12 Mar 2026 12:48:43 +0000

Four Friends. One Startup. Seven Months of API Collections. One Very Bad Tuesday Morning

We have a group chat called "The Actual Startup" — emphasis on actual, because we'd been talking about building something together since college and never quite did. Then last August, we finally did.

Four of us. Me, Akshay, Priya, and Nishank. Different strengths, same timezone, one shared Notion doc nobody fully updates, and a B2B tool we've been quietly building for seven months. It involves a backend, a few internal services, a payment integration, and the kind of API surface that grows faster than you expect when you're moving fast.

We were using Postman. Of course we were using Postman. Everyone uses Postman.

Six collections. Four environments. Staging tokens, production tokens, OAuth flows, webhook payloads, mock responses for the endpoints Akshay hadn't built yet. The workspace had become our undocumented documentation — the living memory of every API decision we'd made.

Then came the email.

What Postman Actually Changed — And Why It Hits Differently When You're Building Something

Nishank found it first. He sent it to the group chat on a Tuesday morning with zero commentary, just the screenshot. We all went quiet for about two minutes, which in our group chat is the equivalent of a full emergency meeting.

Here's what actually changed, because I've seen a lot of hot takes that miss the specifics:

Effective March 1, 2026, Postman's Free plan became strictly single-user. Not reduced features, not lower limits on requests — single user. The collaborative workspace that four engineers had been sharing, synchronizing, building on top of? Gone from the free tier. If you want two or more people working out of the same Postman workspace, you're on the Team plan at $19 per user per month, billed annually.

For the four of us, that math looks like this:

4 users × $19/month = $76/month
Annualized: $912/year

To collaborate on HTTP requests together.

I want to be fair — Postman is a real company that built real infrastructure. Their paid tier has genuinely advanced features: AI test generation, Git workflow integration, API governance. These things cost money to build. A business needs to fund itself.

But here's what stings: we don't need AI test generation. We need to open the same workspace and see the same environments. That basic function — free for years — is now nearly a thousand dollars annually for a four-person pre-revenue team.

The difference between a price increase and a betrayal is usually whether the thing removed was something you built your workflow around. For us, this was the latter.

Why "Just Find Another Tool" Misses the Point

Our Postman workspace wasn't a list of saved requests. It was institutional memory.

Akshay had organized collections to mirror our service architecture. Priya ran QA flows from them and had added test scripts on top. Nishank used specific environment configs to reproduce production bugs in staging. I relied on pre-request scripts to handle token refresh before hitting auth-protected endpoints.

Take that workspace away and you don't just lose requests — you lose the accumulated knowledge of how your team thinks about your own system.

Our constraints were specific: clean import fidelity, real team sync, free or close to it, and zero disruption to a running sprint. We spent a weekend seriously testing three tools.

The Three Tools We Evaluated

Requestly — The One We Keep Coming Back To

None of us knew Requestly as an API client. Priya had the browser extension installed for intercepting requests in dev tools — the thing you use once for a specific debugging problem and forget about. Turns out they'd been building a full API client, and the heritage shows.

The core insight is that Requestly didn't try to clone Postman. Starting from the browser interceptor world, it built something that does two things simultaneously that every other client separates. You can write and save requests in collections the normal way — environments, variables, the full Postman mental model. But you can also intercept live requests from your running application, modify them mid-flight, and replay them. No proxy setup, no Charles, no context switching.

For Priya, this collapsed two workflows into one. She'd been manually reconstructing in Postman requests she could already see in the network tab. With Requestly, you see the live request, modify it, save it to the collection. Done.

Import was the best we tested. All six collections, four environments, nested folders, auth configs — everything came over cleanly. One pre-request script needed a five-minute syntax fix. That was the full migration cost.

The collaboration model is Git-backed, which took adjustment. Collections live on disk and sync through your repository. Initially this felt like friction. After two weeks it feels correct — our collection history is in the monorepo, collection updates live alongside the code they test, and new engineers get a working API setup on day one by just cloning the repo.

Open source, free team collaboration, and it does something Postman genuinely cannot. That combination won the evaluation.

Insomnia — The Path of Least Resistance

If Requestly asks you to think slightly differently, Insomnia asks nothing of you at all.

The interface maps so closely to Postman that Akshay had a collection running within ten minutes, no onboarding. Same panel layout, same environment switcher, same keyboard shortcuts. The muscle memory transfers almost completely. Maintained by Kong, it's not going anywhere.

Where Insomnia genuinely pulls ahead: GraphQL. Native schema introspection, a proper query builder, solid subscription handling. If Postman's GraphQL support always felt bolted on to you, Insomnia treats it as a first-class concern — and the difference is immediately obvious. For gRPC-heavy teams it's similarly strong.

One more thing worth noting: the plugin ecosystem. Insomnia has a mature library of community plugins for things like AWS Signature auth, custom response visualizations, and OpenAPI linting. If your API work involves non-standard auth flows or specialized protocols, Insomnia's extensibility might matter more than any other factor.

The honest limitation: team collaboration is behind a paywall. Insomnia's free tier is excellent for individuals but doesn't solve the shared workspace problem. If you're willing to pay something but not $912/year, Insomnia's paid tiers are notably cheaper than Postman's and the migration friction is the lowest of any alternative we found.

Hoppscotch — Zero Install, Full Control

Priya suggested this one. We were skeptical — a browser-based API client sounds like something you'd use at a hackathon and forget.

We were wrong.

Hoppscotch is a progressive web app. Nothing to install. Open a tab, test APIs. REST, GraphQL, WebSocket, SSE — the full range. Collections, environments, pre-request scripts, team workspaces. It works, and it's fast.

The self-hosting story is what makes it genuinely interesting. Akshay had a Docker instance running on our dev server in under an hour. Our collections, our environment variables, our workspace — on our own infrastructure. No third-party cloud storing our staging credentials. For a startup handling payment data, knowing exactly where your API configs live isn't paranoia — it's sense.

The ceiling is real: browser-first architecture hits limits at scale — large collection management, heavy chained test suites, complex pre-request scripting. For where we are, those aren't limits we've reached. If you're evaluating for a more mature codebase, worth stress-testing.

Cloud paid tier if you'd rather not self-host: $12/user/month — still cheaper than Postman's Team plan.

Where We Are Right Now

We haven't done a hard cutover. We're mid-sprint, and breaking working toolchain infrastructure mid-sprint is how you have a very bad week.

What we've done: everyone has Requestly installed, all collections imported, running both tools in parallel while we validate. Hoppscotch self-hosted is live for quick browser-based testing — it's earned its place for anyone who needs to hit an endpoint from a machine that doesn't have Requestly configured.

"Better in some ways I didn't expect. The interceptor thing is actually useful, not just a demo." — Nishank, after two weeks

"It's free. That's the whole take." — Akshay

Priya hasn't filed any complaints, which for QA is the highest possible signal.

Full cutover is two weeks out. The sprint ships first. Then Nishank updates the spreadsheet.

The Actual Cost of This Disruption

Hard cost in new tooling: zero.

Soft costs nobody writes about but everyone feels:

The evaluation itself. A Saturday and a few evenings. Every hour spent on tooling decisions is an hour not spent building. The frustrating thing about Postman's change isn't the $912 — it's that it forced a conversation we didn't want to have.
Import validation. You cannot trust that import worked without checking. We spot-checked forty-odd requests and ran smoke tests. Several hours. Non-skippable.
Habit re-wiring. A week of small frictions — keyboard shortcuts that don't match, UI patterns that sit in different places. It fades, but it's real.
Documentation. We had Postman screenshots in our onboarding doc. Updated. Not hard, just time.

Total real engineering hours across the team: eight to ten. That's what Postman's pricing change cost us, in practice.

What I'd Tell a Team Starting This Today

Developer-first team that thinks in Git: Requestly's model will feel natural within a week. The Git-backed sync, open-source codebase, and interceptor capability give you genuine upside — not just a Postman replacement.
Want maximum behavioral compatibility, willing to pay less: Insomnia is the smoothest migration available. Muscle memory transfers, the GraphQL story is stronger, the plugin ecosystem is mature. Budget for the team tier.
Value data ownership or need zero-install access: Hoppscotch self-hosted is an hour of setup and then it's just there. Low maintenance, full control.

Tooling decisions are supposed to be boring. When you're building an MVP, they mostly are — until a pricing change ripples through your entire collaborative workflow on a Tuesday morning you didn't plan for.

The good news is that the developer ecosystem has genuinely matured. Postman is no longer the only serious place to work with APIs, and the alternatives aren't compromises. Some of them are better, depending on how you work.

We came in looking for a replacement. We're leaving with a workflow we actually prefer.

The rug got pulled. Turns out the floor underneath was always there — we just never had a reason to look.

Navigating the same thing with your team? Curious which tools you landed on, especially if you hit edge cases we didn't. Drop a comment.