We cut our dev stack from 22 tools to 14. Here's exactly what survived and why.

Six months into building Nventory we had 22 tools running simultaneously.
Not because we planned it that way. Because every problem got a new tool. Every new hire brought their favourite stack. Every integration added another dashboard to check.
Then we did a full audit.
Here's what we cut, what stayed, and the specific reasoning behind every decision. No affiliate links. No sponsored mentions. Just what we actually use building multichannel inventory infrastructure at Nventory.

The full cut list — and why each one went
Jira → Linear
Jira works. It does everything. It also requires maintenance, generates ticket overhead, and produces an interface the team works around rather than with.
Linear replaced it in a week. Not because of features — Linear has fewer. Because adoption happened naturally. The engineering team opens it without being asked.
bash# The Jira workflow reality

1. Create ticket (5 min — finding the right project, epic, sprint)
2. Fill in 8 required fields
3. Estimate story points
4. Assign to sprint
5. Move through 6 status columns
6. Close ticket with comment

The Linear workflow reality

1. Hit C — create issue
2. Type the title
3. Hit Enter
4. Done Speed of ticket creation is a proxy for whether developers actually create tickets. Linear wins. Confluence → Notion Confluence is where documentation goes to die. Search doesn't work. Pages nest three levels deep. The editor fights you. Notion replaced it for internal wiki, engineering decisions, integration documentation, content calendar, and meeting notes. One tool. One search. Free tier covered everything for the first year. We didn't upgrade until the team exceeded 10 people. Zoom as default → Loom as default Kept Zoom for meetings that genuinely require synchronous back-and-forth. Changed the default. Every "can you walk me through this" became a Loom first. Every code review explanation. Every design feedback session. Meeting load dropped 40%. Not through mandate — through Loom being faster than scheduling. Postman → HTTPie + VS Code REST Client Postman became a cloud-sync subscription product. The complexity it introduced — workspaces, team sync, version conflicts — exceeded the value for our use case. bash# HTTPie — API testing from terminal # Testing our webhook endpoints during development http POST localhost:3000/webhooks/shopify \ X-Shopify-Hmac-Sha256:abc123 \ topic:orders/create \ shop_domain:example.myshopify.com

Clean. Fast. No account required. No cloud sync.

VS Code REST Client handles the rest:
http### Test inventory sync endpoint
POST http://localhost:3000/api/inventory/sync
Content-Type: application/json
Authorization: Bearer {{token}}

{
"sku": "HOODIE-BLK-M",
"quantity": 47,
"channel": "shopify"
}
Two tools replaced. Both free.
Datadog + New Relic → Grafana + Prometheus + Sentry
We ran Datadog and New Relic simultaneously for two months trying to decide between them. The cost was significant. The insight differential was marginal.
Self-hosted Grafana + Prometheus covers metrics and dashboards. Sentry handles error tracking specifically. Total cost: server hosting. Total capability: comparable.
The four metrics that actually matter for our event-driven sync architecture:
javascript// The dashboard we actually look at
const coreMetrics = {
syncLagP99: 'sync_lag_ms p99 < 5000', // event propagation speed
propagationSuccessRate: 'propagation_success / total > 0.99', // channel update reliability
oversellRate: 'oversell_detected_24h === 0', // zero tolerance
dlqDepth: 'dead_letter_queue_depth < 100' // failed propagations
};

// Every other metric is noise until these are green
Amplitude → PostHog
Amplitude is genuinely powerful. It's also genuinely expensive for a team at our stage.
PostHog self-hosted free tier does 90% of what we needed — funnel analysis, session recording, feature flags, and cohort analysis. The 10% gap isn't worth the cost difference at our stage.
Intercom → Crisp
Intercom enterprise pricing at low support volume doesn't make sense. Crisp free tier handles live chat and basic ticketing. When volume grows to justify Intercom's pricing — we'll revisit. Until then, Crisp.
Retool → Next.js internal tools
This one hurt to cut because the promise was compelling. Drag-and-drop internal tooling without writing code.

The reality: our data model for multichannel inventory sync was complex enough that Retool's abstractions became constraints. Every custom behaviour required workarounds that took longer than just writing the component.

We rebuilt the internal tools in Next.js. Took longer upfront. Significantly easier to maintain. No vendor dependency.
Height → Linear + Notion (separate)
Height tried to unify task management and documentation. In theory — better than two tools. In practice the context switching between engineering mode and documentation mode is actually useful. Different tools for different mental states.

The 14 that stayed
Engineering:
├── VS Code (+ GitLens, REST Client, Error Lens, ESLint, Prettier)
├── GitHub (version control + GitHub Actions for CI/CD)
├── Docker + Docker Compose (local dev)
├── Warp (terminal — AI autocomplete for shell commands)
├── TablePlus (database GUI — free tier sufficient)
├── Proxyman (HTTP debugging — invaluable for webhook debugging)
└── Grafana + Prometheus + Sentry (monitoring + error tracking)

Team:
├── Linear (engineering tasks)
├── Notion (everything else)
├── Loom (async communication)
├── Figma (design — free tier)
└── Slack (communication)

AI:
├── GitHub Copilot (autocomplete — unambiguous ROI)
├── Claude (writing, reasoning, code review)
└── Perplexity (research with cited sources)

The tools worth knowing that didn't make the list but deserve mention
Excalidraw — we use this for every architecture diagram before writing code. Hand-drawn aesthetic removes formality and makes it faster to iterate. Used it to design the order routing engine and event propagation architecture.
Warp — the terminal upgrade that actually matters. AI autocomplete for shell commands is genuinely useful day to day. Worth switching from iTerm2.
Raycast - replaces macOS Spotlight. Clipboard history, window management, Linear integration, GitHub integration. The free tier covers everything.
Proxyman - the tool most developers don't know about until they need it. HTTP proxy for macOS that intercepts and inspects all network traffic. Essential for debugging webhook delivery and API integrations.

The underlying principle
Every tool added creates:
javascriptconst toolCost = {
contextSwitching: 'new mental mode to enter and exit',
decisionFragmentation: 'decisions made in tool nobody else checks',
maintenanceOverhead: 'integrations to maintain, credentials to rotate',
onboardingCost: 'new surface area for every hire'
};

function shouldAddTool(tool) {
const habitualAdoption = team.usesWithinTwoWeeks(tool);
const replacesExisting = tool.eliminates.length > 0;
const valueExceedsCost = tool.timeSavedWeekly * team.size >
Object.values(toolCost).reduce(sum) * tool.complexityMultiplier;

// If the team isn't reaching for it habitually — cut it
return habitualAdoption && (replacesExisting || valueExceedsCost);
}
The question before every addition: does the value created exceed the coordination overhead introduced?
For most tools: no. For the 14 that stayed: yes, demonstrably.

What we're building with this stack
Nventory — multichannel inventory and order management. Event-driven sync across 40+ channels in under 5 seconds. AI automation in plain English. Smart order routing. Free forever.
→ nventory.io
→ Shopify Store

The question for dev.to
What's the one tool you cut that you thought you needed?
And what's the hidden tool — the one nobody puts in their blog post — that changed how your team works?

Drop your actual stack below. Not the aspirational one. The one you actually use every day.