The testing gap nobody's really solving

Here's the thing: you test your API in Postman. You test your React components with Jest. Everything passes. Ship it, right?

Then production hits and... wait, why can't users log in?

Turns out your login form sends username but your backend's expecting email. Both sides tested fine individually. Together? Not so much.

We're in this era where AI's helping us ship code faster than ever, but we're still testing like it's 2015. Something's gotta change.

The problem: we're all testing in our own little bubbles

Look around—everyone's shipping faster now. Cursor, v0, Claude... we're all basically "vibe coding" our way through features. MVPs that used to take months now take days. It's wild.

But here's the catch: testing hasn't kept up.

We test the backend. We test the frontend. Then we cross our fingers and hope they play nice together.

And from what we've heard talking to people (probably 20-ish teams at this point), it's the same story everywhere:

"All our tests are green but users can't check out. Cool."

"I test everything in Postman. Works great. No idea if the frontend's actually calling it right though."

"Backend doesn't know how we're using their APIs. We don't really know what they expect. It's just... vibes."

"We find integration bugs in production because that's the first time everything actually talks to each other."

Why does this keep happening?

Backend tools like Postman are great for testing APIs... as long as you don't care how the frontend's actually using them. Which, you know, seems important.

Frontend tools like Cypress and Jest mock everything. They test the UI against fake data. When the real API doesn't match those mocks? Surprise!

E2E tools can technically test everything together, but they're slow as hell, break all the time, and need a whole team to babysit them.

Monitoring (Datadog, Sentry, etc.) will definitely tell you when things break... after your users have already dealt with it. Great.

What if testing actually understood both sides?

Here's where things are headed (and what we're building):

• AI that can actually read both your frontend and backend code and understand how they're supposed to connect
• Testing that uses your real Postman collections, GitHub repos, or GitLab projects—not mocks
• Tests that run automatically when you commit, when schemas change, when things deploy
• Tools that understand user flows across your whole app, not just isolated pieces

Testing should connect frontend and backend automatically. That's the bet we're making.

Enter OpenTest (yeah, that's us)

So we built OpenTest to actually test the whole stack—not just the backend, not just the frontend, but how they work together. The way users actually experience your app.

Whether you're more backend-focused, frontend-focused, or doing the full-stack juggle, it adapts to your workflow:

Test your live site with just a URL

Got a deployed site? Paste the URL. Our AI navigates it, maps out the pages, figures out the flows, and tests them. No config files, no setup hell. It just works.

Connect your API schemas

Already have stuff in GitHub, GitLab, or Postman? Connect it. OpenTest reads your actual schemas and tests how your frontend's really using them—with real data, real endpoints, real flows. No mocks.

Full-stack testing that actually makes sense

Want to test login? OpenTest looks at your Postman collection, figures out the auth flow, navigates to your login page, and tests the whole thing end-to-end. Frontend interaction + backend authentication. Together.

For bigger apps, it builds a map of your entire site—every page, every route, every API call. So when something changes, it only retests what's affected. No wasted time.

AI that actually helps

There's an AI agent that helps you plan tests, runs them across your stack, and gives you actual useful reports. Think of it like having a QA person who doesn't need sleep (or coffee breaks).

Automatic testing on every change

Push to GitHub? We catch it and retest what changed. Update a schema? We validate the integration. We track which endpoints map to which pages, so we're not wasting your time retesting everything.

Works for everyone

• Backend devs: Finally see how frontend's actually calling your APIs. Catch problems before they ship.
• Frontend devs: Test against real backend behavior instead of mocks that lie to you.
• Full-stack devs: Test everything in one place. No more tool-hopping.

What it looks like in practice

Here's the difference:

The old way

With OpenTest

"OpenTest caught a bug in our checkout that would've killed our conversion rate. Backend was fine. Frontend was fine. But the data shape was off. We would've never caught that with Postman or Jest alone."

— Someone from an e-commerce startup (they're in our beta)

Who's this for?

Honestly? Anyone shipping web apps:

Backend devs

Finally see how your endpoints are getting used. Catch issues before frontend even knows there's a problem. Stop wondering if your changes will break stuff.

Frontend devs

Ditch the mocks. Test against actual backend behavior. Find schema issues before they hit staging. Validate real flows, not imaginary ones.

Full-stack devs

Test everything in one place. No more juggling Postman and Playwright. Just one tool, one report, actually useful results.

Works especially well for:

• Startups shipping fast without a dedicated QA team
• Remote teams where backend and frontend aren't in the same room (or timezone)
• Teams that want to build features, not maintain test infrastructure
• Anyone tired of integration bugs slipping through

Why we think this matters

Testing needs to catch up with how fast we're building now. And it needs to understand that apps aren't backend OR frontend—they're both working together.

Your login page and your auth API aren't separate things. Your checkout UI and your payment endpoint aren't independent pieces. Users experience the whole stack. Testing should too.

The next wave of dev tools isn't just about speed. It's about tools that actually understand your system— how frontend talks to backend, where the connections are, where things can break. Tools that catch problems automatically so you can focus on building instead of debugging integration issues at 3am.

That's what we're trying to build with OpenTest.

Built by developers, for developers.

OpenTest AI

"Build faster. Test smarter."

Tech stack (if you're curious)

For anyone wondering what's under the hood:

• Backend: Node.js (fast, flexible, gets the job done)
• Frontend: Next.js (because modern React is pretty great)
• AI: Currently running DeepSeek 3.2—good balance of cost and capability. You can swap in your preferred model if you want.
• Code understanding: AST parsing + knowledge graphs to actually understand your codebase
• Database: PostgreSQL (reliable, boring in the best way)
• Hosting: Railway for dev/test environments. Looking at AWS for production scale.