Simulate Distributed Systems with SystemFlow

I thought WebSockets were basically free. But after our Sunday web dev cohort class by Piyush Garg I found out they’re not. Not even close. An idle WebSocket connection still costs your server: ~1 KB → TCP file descriptor ~128 KB → buffers (even idle uses ~4–6 KB) ~2–5 KB → library overhead whatever app state you attach That’s before sending a single message. Now imagine this: 100,000 connections = 2 to 10 GB RAM gone Just… sitting there. No business logic. No processing. Just connections. Meanwhile HTTP: ~5–20 KB per request Lives for ~50 ms Then disappears The real cost isn’t size. It’s time. HTTP → milliseconds WebSockets → minutes, hours, sometimes forever At scale, you're not building a backend anymore. You're running a connection warehouse. 100K open file descriptors 100K kernel buffers 100K in-memory objects And you’re paying for all of it. This is why polling isn’t dead. It’s just… misunderstood. Before you jump to WebSockets, ask one brutal question: 👉 Do I really need real-time… or do I just want it? Because that answer can save you gigabytes of RAM and a lot of money. --- I got curious about how far this goes — so I built something fun: A 1 Million Checkboxes app running on a single DigitalOcean machine to test WebSocket load in the wild. Try breaking it 👇 https://lnkd.in/gzmZx9ZD Hitesh Choudhary Piyush Garg --- #websockets #backend #systemdesign #scaling #Javascript #devops #programming #softwareengineering

Ever wondered why Vite always runs on port 5173? 🤔⚡  why not 3000 or 5000 ? Why specifically 5173. I’ve been doing developement for the past 1.5 years, and surprisingly, I just discovered the reason behind this — and it’s actually pretty interesting 😄 . When Vite was created, the developers wanted a default port that’s unlikely to conflict with commonly used ports like:   👉 3000/5000 (React , Node apps)   👉 8080 (servers)   👉 4200 (Angular)  So instead of picking a random number, they chose 5173 — and here’s the fun part:   💡 It resembles somewhat like the word “VITE” if you look closely. 📱 V → 5 ( V in roman) 📱 I → 1  ( somewhat like I ) 📱 T → 7 ( somewhat like flipped t )   📱 E → 3 ( mirored E ) So 5173 became a unique, recognizable, and low-conflict port that stands out in development environments 🚀 . ✨ It’s small details like these that make you appreciate the thought process behind modern tools. This is not officially declared , but this could be one reason . Sometimes, even after months of coding, you still uncover these hidden gems — and that’s the beauty of tech ❤️  #WebDevelopment #Vite #JavaScript #Frontend #Developers #Learning #TechJourney #CodingLife

REST APIs vs WebSockets. Most devs pick the wrong one. I spent months reaching for WebSockets on everything — until I realized I was over-engineering 90% of my apps. Here's the honest breakdown: REST APIs are your default. Use them when: → You're doing standard CRUD operations → Your data doesn't need live updates → You want caching, easy scaling, and broad client support REST is stateless. Every request is self-contained. That simplicity is a feature, not a limitation. WebSockets are for real-time, two-way communication. Use them when: → You're building chat, live notifications, or multiplayer features → The server needs to push data without being asked → Polling feels wasteful (because it is) Think Slack, live sports dashboards, or collaborative editing. WebSockets keep a persistent connection open — lower per-message overhead, but more resource cost on your server. The mental model that clicked for me: REST = sending a letter. WebSockets = a phone call. Letters are great for most things. But if you need a live conversation, you pick up the phone. Building Elite Apply and Colo AI, I defaulted to REST for almost everything. I only added WebSockets when real-time was genuinely non-negotiable. Start simple. Feel the pain. Then upgrade. What's the most complex real-time feature you've built? I'd love to hear it 👇 #webdevelopment #javascript #nodejs #softwareengineering #buildinpublic

Using too much LocalStorage in your project? Here's why that's risky. LocalStorage is convenient — but it has limits. What goes wrong: • It only holds ~5MB per browser • Hitting the limit = app crashes or stops saving data • It's never encrypted; sensitive data is exposed • Clears when the user wipes browser data • Slows your app if you store large/complex objects What to do instead: • Store only small, non-sensitive data (theme, language, UI prefs) • Use a backend database for real data • Use IndexedDB for large client-side storage • Never store passwords, tokens, or personal info • Clean up old keys you no longer use Rule of thumb: LocalStorage is a sticky note, not a database. Treat it like one. #WebDev #JavaScript #Frontend #Programming #TechTips

Today I wrote code that knows when someone walks in the room. That is a WebSocket connection in one sentence. A client connects. The server logs it. That is it but that single event is the foundation of everything real-time. Chat apps, live notifications, collaborative tools. It all starts here. The interesting part is not the code. It is why Socket.io exists at all. Raw WebSockets are powerful but you end up building a lot yourself. For ex: reconnection logic, transport fallbacks, error handling. Socket.io handles that out of the box. Using it is not taking a shortcut. It is choosing the right tool. Today's work: Basic Socket.io setup and configuration Logging client connections on the server side Foundation laid for deeper experimentation tomorrow One small log statement. But tomorrow the real experiments begin by connecting the concepts of WebSockets and Socket.io, and eventually integrating this into an actual project. #207days in and sometimes the most important sessions are the ones where you just get the scaffolding right so the real learning can happen. Source: https://lnkd.in/dF5PZhDr #WebSockets #SocketIO #buildinpublic #100daysofcode #JavaScript

⚡ Long Polling vs WebSockets vs SSE - Which one should you use? When building real-time apps, many developers use these terms interchangeably. But they solve communication in very different ways. Here’s the simple breakdown 👇 1️⃣ Long Polling Client sends request to server. Server holds it until new data is available. Response returns → client immediately sends another request. So connection keeps reopening again and again. ✅ Easy to implement ✅ Works on old systems ❌ High overhead ❌ More latency than true real-time options Best for: occasional updates when traffic is low. 2️⃣ Server-Sent Events (SSE) Client opens one HTTP connection. Server keeps pushing updates continuously on that same connection. Only server → client communication. ✅ Lightweight ✅ Better than long polling ✅ Great for notifications/live feeds ❌ Client cannot send continuous data back on same channel Best for: stock prices, live alerts, dashboards. 3️⃣ WebSockets Single persistent connection between client and server. Both client and server can send data anytime instantly. True full-duplex communication. ✅ Lowest latency ✅ Two-way real-time messaging ✅ Highly scalable for chat/live apps ❌ Slightly more setup and infra handling Best for: chats, multiplayer games, collaborative tools. Quick Rule of Thumb 🧠 🔹 Need simple fallback → Long Polling 🔹 Need one-way live updates → SSE 🔹 Need full real-time two-way communication → WebSockets Choosing the wrong one can silently hurt: 1. Bandwidth ⚠️ 2. Server load ⚠️ 3. User experience ⚠️ Real-time architecture is not just about "making it live", it's about making it efficient. 👉 If you are preparing for Java backend interviews, connect & follow - I share short, practical backend concepts regularly. #Java #SpringBoot #BackendDevelopment #SystemDesign #WebSocket #SSE #LongPolling #SoftwareEngineering

Building browser extensions has been one of those experiences that looks simple from the outside… but feels completely different once you get into it. At first, it’s not the coding that challenges you — it’s the architecture. You’re suddenly dealing with: • Multiple environments (popup, background, content scripts) • Messaging between different layers • Strict permissions and manifest rules • Debugging across separate consoles And honestly, that’s where most of the friction comes from. But here’s the interesting part — once the mental model clicks, everything starts to feel structured and predictable. It shifts from “Why is nothing working?” → to → “Okay, I know exactly where this belongs.” That’s when real progress happens. One thing that helped me: Break the system into layers and build step by step instead of trying to solve everything at once. Still learning, still building — but definitely understanding things at a much deeper level now. #webdevelopment #chromeextensions #buildinpublic #softwareengineering #learning

🚀 Built a self-hosted network monitor for my home lab — RouterHub Wanted full visibility into what's happening on my home network without relying on the router's clunky built-in UI. So I built one. What it does: - Real-time per-device bandwidth (download/upload) via WebSocket — updates every 2 seconds - Historical rate charts (1h / 6h / 24h / 7d) and daily usage bar charts per device - Pin favourite devices to the top - Auto-detects wired vs Wi-Fi vs Mesh connections - Fully self-hosted on a Ubuntu home server, served from a single Docker container Stack: Node.js · Express · Socket.io · SQLite · React · Recharts · Tailwind CSS What made this build different — OpenWolf 🐺 I used OpenWolf as an AI context management layer throughout development. It maintains a living memory of the project — conventions, past mistakes, architectural decisions — across every session. No re-explaining the codebase each time. Thanks Mitchell Ross for the Tip. The result: a production-ready app built faster and with more consistency than I expected. https://lnkd.in/gzUr9AmY #homelab #networking #selfhosted #react #nodejs #docker #buildinpublic #OpenWolf #AI #claudecode

Still Polling Your Backend Every 5 Seconds? There's a Better Way. Most developers build real-time features wrong. They set up a setInterval to call GET /notifications repeatedly - burning server resources on empty responses, adding latency, and scaling poorly under load. WebSockets flip the model. Instead of your frontend asking "anything new?" every few seconds, your backend speaks up the moment something happens. One persistent connection. Zero wasted requests. Events delivered in under 100ms. Pusher Channels takes this further by handling the WebSocket infrastructure for you - no managing connections, reconnections, or message routing yourself. Your backend calls a single function. Your frontend receives it instantly. The pattern works beyond notifications: live chat, collaborative cursors, order tracking, real-time dashboards - anything where waiting for the next poll is one second too long. I built a small proof-of-concept with Express and Next.js to show exactly how this works, including public channels for system-wide broadcasts and private channels for user-specific events. 🔗 GitHub: https://lnkd.in/gzumnzD9 #WebSockets #Pusher #RealTime #NodeJS #React #WebDev

Interesting development: browser-use/browser-harness: Self-healing browser harness that enables LLMs to complete any task. With 3141+ upvotes on Github Trending, this clearly resonates with developers. My quick take: the teams that pay attention to shifts like this are the ones shipping better products 6 months from now. Read more: https://lnkd.in/egnXQWxD Agree or disagree? I'd love to hear your perspective.