Redesign main page: industries, customers, LLM visibility

src/blog/anycable-vs-socket-io/index.md

@@ -0,0 +1,108 @@
+# AnyCable vs Socket.io: built-in reliability vs roll-your-own
+
+April 1, 2026
+{date}
+
+<br/>
+
+Socket.io is the most popular WebSocket library in the JavaScript ecosystem. It's battle-tested, well-documented, and free. So why would you use AnyCable instead? Because Socket.io doesn't guarantee delivery — and in production, that's the problem that breaks everything else.
+{intro}
+
+<div class="divider"></div>
+
+## Socket.io doesn't guarantee delivery
+
+This is the core difference between the two tools, and everything else flows from it.
+
+Socket.io provides **at-most-once delivery**. Their own [documentation][socketio-delivery] says it plainly: "if the connection is broken while an event is being sent, then there is no guarantee that the other side has received it." There is no retry, no buffering for disconnected clients, and no catch-up on reconnection.
+
+AnyCable provides **at-least-once delivery**. Publications are stored in logs. The client tracks its stream position. On reconnection, it automatically recovers every missed message. Your application code doesn't change — you broadcast messages, and every client receives every one of them, even through disconnections.
+
+This matters more than you think. WebSocket connections are not as reliable as they appear in development. In production, micro-disconnections happen on stable connections, longer interruptions occur during commutes and subway rides, and every server deploy severs active connections. Without delivery guarantees, every one of these events silently corrupts your client state.
+
+### What this looks like in practice
+
+**Live chat:** A user enters a tunnel for 3 seconds. Two messages arrive in the group chat during that window. With Socket.io, those messages are gone — the user sees an incomplete conversation. With AnyCable, the client catches up automatically on reconnection.
+
+**LLM/AI streaming:** You're streaming an AI response word by word. The client briefly loses connection mid-sentence. With Socket.io, the response is truncated or garbled — chunks are lost with no recovery. With AnyCable, every chunk is recovered in order. As we described in our article on [the pitfalls of LLM streaming][llm-streaming], this is a real production problem that breaks AI-powered features.
+
+**Real-time dashboards:** A monitoring dashboard shows live metrics. A 200ms network blip causes a gap in the data. With Socket.io, that gap is permanent. With AnyCable, the missed data points are recovered and the chart stays complete.
+
+**Deploys:** You ship code. With Socket.io, every WebSocket connection is severed — every client must reconnect, and any in-flight messages are lost. With AnyCable, the Go-based WebSocket server is a separate process from your application. When you deploy your app, the WebSocket server stays up. Connections are never interrupted. Users never notice a deployment.
+
+As Doximity engineers [described on the On Rails podcast][doximity-podcast]:
+
+> "AnyCable allows them to keep that connection open. That Go service stays up, and you can continue shipping your Rails application as normal."
+
+## A standalone server, not an embedded library
+
+Socket.io is a library you embed in your Node.js application. It runs in the same process as your business logic, competing for the same CPU and memory.
+
+AnyCable is a standalone server written in Go. It handles WebSocket connections independently — your application communicates with it via HTTP API. This separation has three consequences:
+
+1. **Scale independently.** Need more WebSocket capacity? Scale AnyCable. Need more app server capacity? Scale your app. They don't compete for resources.
+
+2. **Deploy independently.** Ship code to your app without touching WebSocket connections. This is why connections survive deploys.
+
+3. **Use any backend language.** Socket.io locks you into Node.js. AnyCable works with Rails, Laravel, Node, Python/FastAPI, or any backend that can make HTTP requests. Broadcast a message from any language:
+
+```
+POST /api/v1/broadcasts
+{ "stream": "chat/42", "data": "{\"message\": \"hello\"}" }
+```
+
+### Why Go for WebSockets
+
+WebSocket connections are long-lived — a user can hold one open for hours. In Node.js, each connection consumes meaningful memory in the V8 runtime. At 10,000 concurrent connections, this adds up fast.
+
+Go's goroutine-based concurrency model handles long-lived connections with minimal overhead. AnyCable serves 10,000+ concurrent connections per server using a fraction of the memory that Node.js or Ruby would need. And Go compiles to a single binary — no `node_modules`, no runtime version conflicts.
+
+## What you don't have to build
+
+With Socket.io, you get a WebSocket transport and rooms. Everything else is your responsibility:
+
+| What you need | Socket.io | AnyCable |
+|---------------|-----------|----------|
+| Reliable delivery | No (at-most-once) | Built-in (at-least-once) |
+| Missed message recovery | No catch-up mechanism | Automatic on reconnection |
+| Presence (who's online) | Build it yourself | Built-in |
+| Authentication | Build your own middleware | JWT, signed streams |
+| Pub/sub clustering | Redis adapter (separate setup) | Embedded NATS (zero extra infra) |
+| Monitoring | Add your own | Prometheus & StatsD built-in |
+| Binary compression | No | Yes (Pro) |
+| Deploy resilience | Not possible (same process) | Built-in (separate server) |
+
+Each of these is weeks of engineering work to build properly, and months to battle-test in production. AnyCable ships them as built-in primitives because we've been doing this since 2017.
+
+## Proven at scale
+
+AnyCable has been powering real-time features in production since 2017, for companies like:
+
+- **Doximity** — telehealth for 80% of US physicians
+- **CoinGecko** — cryptocurrency market data at massive scale
+- **Jobber** — field service management ($167M revenue)
+- **Headway** — mental health therapy ($2.3B valuation)
+- **Circle** — community platform ($30M+ raised)
+- **ClickFunnels** — sales funnels (~$265M revenue)
+
+The project is actively developed with regular releases, a dedicated team, commercial Pro support, and a growing ecosystem including [Laravel support][laravel-post], [Pusher protocol compatibility](https://docs.anycable.io/guides/pusher), and the emerging [Durable Streams](https://docs.anycable.io/guides/durable_streams) standard.
+
+## When Socket.io is the right choice
+
+To be fair: if you're building a small Node.js app, prototyping, or need full control over a custom protocol, Socket.io is a fine choice. It's well-documented, has a massive community, and is free.
+
+But if you need delivery guarantees — and in production, you almost certainly do — you'll end up building them yourself on top of Socket.io. AnyCable gives you delivery guarantees, presence, authentication, and scaling out of the box, with any backend language, tested in production by companies serving millions of users.
+
+## Get started
+
+- [Documentation](https://docs.anycable.io)
+- [Rails getting started guide](https://docs.anycable.io/rails/getting_started)
+- [Laravel guide](https://docs.anycable.io/guides/laravel)
+- [JavaScript/TypeScript client](https://github.com/anycable/anycable-client)
+- [GitHub](https://github.com/anycable/anycable)
+- [AnyCable Pro](https://plus.anycable.io/pro) — free 2-month trial
+
+[socketio-delivery]: https://socket.io/docs/v4/delivery-guarantees
+[llm-streaming]: https://evilmartians.com/chronicles/anycable-rails-and-the-pitfalls-of-llm-streaming
+[doximity-podcast]: https://podcast.rubyonrails.org/2462975/episodes/17653501
+[laravel-post]: https://evilmartians.com/chronicles/anycable-for-laravel