Why I built OpinioM — the chat SDK I wanted to exist

OpinioM is a drop-in real-time chat SDK for web apps. Use it with a plain script tag, a React component, or fully headless. Here's why I built it.

I kept running into the same problem.

A while back I was building the backend for an edtech app. One of the requirements was chat: teachers needed private conversations with students, plus group rooms. On paper it was a tiny part of the project.

It wasn't tiny.

The hard part wasn't the messaging, it was everything around it. Dynamic permissions across different access levels. Making sure delivery and real-time sync actually held up. A pile of custom logic that didn't fit cleanly into GraphQL subscriptions. The server overhead and the architectural complexity were wildly out of proportion to how small the feature was supposed to be.

And it kept happening. Every time I needed chat in an app, just a basic feature, the kind a product manager describes in one sentence, it turned into weeks of work. Not because chat is glamorous, but because "real-time messaging" quietly expands into a dozen hard problems the moment you start.

You need a WebSocket layer that survives flaky networks. You need reconnection logic with backoff, so a subway tunnel doesn't permanently disconnect someone. You need presence, so people know who's online. You need message ordering, because messages arrive out of order more often than you'd think. You need read receipts, typing indicators, file uploads, and a way to authenticate end-users without leaking your secret keys to the browser. And once it works on your laptop, you need it to keep working when two thousand people use it at once.

Meanwhile, the actual product I was trying to build, the thing my users actually cared about, sat waiting.

The two bad options

When you hit this wall, you usually have two choices, and both are bad.

Option one: build it yourself. This is the "it's just a WebSocket" trap. You wire up Socket.io in an afternoon, demo it, and feel great. Then reality arrives: a dropped connection here, a duplicated message there, a memory leak in your presence tracking, a race condition in your read receipts. Three weeks later you're maintaining infrastructure instead of shipping your product, and you've become an accidental expert in something you never wanted to learn.

Option two: pay an incumbent. The established chat platforms are genuinely good. They're also priced for companies that already have revenue. Several of them start around $499 a month, before you've validated anything, before you have a single paying user, before you even know if people want the feature. Paying enterprise prices to test a hypothesis is how indie projects die quietly.

I wanted a third option. Drop chat into my app in an afternoon, pay nothing until it actually mattered, and never touch a WebSocket again. That option didn't exist, so over the last few months, I built it.

What OpinioM is

OpinioM is a chat SDK you can drop into any web app in a few minutes. Real-time messaging, presence, file sharing, reactions, and webhooks, without running any of the infrastructure yourself.

The whole point is that the integration is boring. You sign a short-lived token on your backend, so your secret key never touches the browser, then create a client and mount the widget. Here's the React version:

import { OpinioMProvider, ChatWidget } from "@opiniom/react";

function App() {
  return (
    <OpinioMProvider projectKey="ok_live_your_key" jwt={userToken}>
      <YourApp />
      <ChatWidget />
    </OpinioMProvider>
  );
}

That's a floating chat widget, live, in the corner of your app. Not using React? It's the same two steps in plain JavaScript: createClient() then mount(). And there's a headless core if you'd rather build the UI yourself.

If the pre-built widget isn't what you want, you don't have to use it. The same SDK exposes 25+ React hooks, like useMessages, useSendMessage, useConversations, and usePresence, so you can build a completely custom chat UI on top of the same real-time engine. And underneath that is a framework-agnostic core client, if you're not using React at all.

Three layers, one engine: drop-in widget, headless hooks, or raw core. You pick how much control you want.

The things that took the longest

The parts that took the most time are exactly the parts you'd rather not build yourself:

• Reconnection that actually works. Exponential backoff, heartbeats, and a state machine that knows the difference between "briefly offline" and "genuinely disconnected."
• Offline support. Messages are cached in IndexedDB, so the UI doesn't go blank the moment the connection drops.
• Security that doesn't leak. Your backend signs end-user JWTs with your secret key; the browser only ever sees a short-lived token. Per-project CORS allow-lists and HMAC-signed webhooks round it out.
• Scaling. The real-time layer runs through a Redis adapter, so it works across multiple server instances, not just one process on one box.

None of that is visible when it works. All of it is painful when it's missing.

Free until it matters

OpinioM is free up to 1,000 monthly active users. No credit card required to start.

That number is deliberate. It's enough to launch a side project, run a beta, or validate a feature with real users before you spend anything. The pricing only kicks in once you have enough usage that paying for it is an easy decision, which is exactly how I wish more developer tools worked.

This is a launch, not a victory lap

I want to be honest about where this is. OpinioM is new. The product is built and documented, but it's early, and I'd much rather have ten developers using it and telling me what's broken than a hundred who signed up and bounced.

So if you've ever hit the same wall, if "just add chat" has ever eaten a week of your life, I'd genuinely value your feedback. Try the quickstart, drop a widget into something, and tell me where it's rough.

I built the thing I wanted to exist. Now I want to find out if it's the thing you wanted too.