NexusRTC

Most quick video calls are trapped between two bad options: enterprise tools that force account setup for a 5-minute discussion, or toy WebRTC demos that break as soon as real users join from different networks. Students and small teams need a browser-native room they can create instantly, protect with a password, and share with one link — with reliable signaling, lobby controls, chat, and screen share.

The hard part is not rendering a video element; it is building the production edge cases: waiting-room flow, session tokens, reconnect behavior, ICE restarts, secure recording downloads, room cleanup, and abuse controls (rate limiting, max peers, TTL). NexusRTC is built to close that gap: a practical 2–6 participant real-time calling system with no sign-up friction.

Solo Full-Stack Engineer & Product Owner — I designed and shipped NexusRTC end-to-end.

**Frontend:** Next.js 14 + React 18 + TypeScript app with dark/light UI, room creation and password gate, waiting-room screens, live participant grid layouts (Auto/Grid/Spotlight/Sidebar), in-call dock controls (mic/camera/screen-share/hand-raise/reactions/layout), encrypted chat panel, and recording status indicators.

**Realtime layer:** Socket.io for signaling + chat channels (/socket.io), peer lifecycle events, waiting-room moderation (admit/deny/admit-all), typing indicators, reaction broadcasts, and reconnect recovery.

**Media layer:** WebRTC mesh P2P for camera/audio/screen tracks with dynamic ICE config fetched from /api/ice-config; peer reconnection with ICE restart (iceRestart: true) on failed/disconnected states.

**Backend & security:** Custom Node server (server.js) with in-memory room state, bcrypt room passwords, session token auth, creator token for host rejoin, rate limiting, room TTL cleanup, recording upload auth, signed one-time recording downloads, and optional FFmpeg MP4 transcode pipeline.

NexusRTC runs as a **single Node process** combining Next.js app routes and Socket.io realtime transport.

1$  Browser A  ◀──────── WebRTC mesh · SRTP media ────────▶  Browser B
2$     │                                                        │
3$     └──────────────────┐                  ┌──────────────────┘
4$                        ▼                  ▼
5$                 Single Node process (Render)
6$        ┌───────────────────────────────────────────┐
7$        │  Next.js app  +  Socket.io signalling      │
8$        │  /api/room/create · /api/room/verify       │
9$        │  /api/ice-config  · /api/recordings        │
10$        │  in-memory rooms · bcrypt · session tokens │
11$        └───────────────────────────────────────────┘

**Core topology:** - Browser ↔ Browser: WebRTC media (SRTP) in mesh mode - Browser ↔ Server: Socket.io for signaling/chat/presence - Browser ↔ API routes: room create/verify, ICE config, recording upload/download, health

**Room flow:** 1. Host creates room via POST /api/room/create with room name + password. 2. Server stores room in memory (hashed password, lobby enabled, max peers, host token, session map). 3. Guest verifies password via POST /api/room/verify and receives session token. 4. Socket.io connects with { roomId, token }; if lobby is on, guest waits for host admission. 5. On admission, signaling (offer/answer/candidate) starts and peer mesh connects.

**Security model:** bcrypt (12 rounds) password hashes, UUID session tokens (TTL), creator token for host return, upload auth on recordings, signed one-time download tokens (1-hour TTL), and action-wise sliding-window rate limits.

**Recording path:** client MediaRecorder captures composite meeting view, uploads to POST /api/recordings, server stores private files outside public static paths, returns short-lived signed URL for download.

**Ops constraints:** room/session/chat state is memory-backed (fast but single-instance). For horizontal scale, state should move to Redis and recordings to object storage (S3/R2).

NexusRTC targets the **instant-call wedge**: teams and students who want to jump into private video in seconds without account onboarding. Positioning is straightforward: *create room, share link, talk now*.

The product-led loop is strong for demos and referrals — one person creates room, others join in browser, no install. This lowers drop-off versus tools that require signup before first call.

Go-to-market is portfolio + open-source credibility: live app for hands-on testing and GitHub repo for technical depth. Potential monetization (not shipped) could include larger room limits, cloud recording retention, and persistent room history.

Live at nexus-rtc.onrender.com with source on GitHub.

**Shipped user features:** password-protected rooms · host-controlled waiting lobby · one-link join flow · WebRTC video/audio · screen share · hand raise + emoji reactions · encrypted chat with typing indicators and image sharing · participant count · layout switcher · recording indicator · dark/light mode.

**Shipped platform features:** Socket.io signaling and chat channels · runtime ICE config API · session/creator token auth · room TTL cleanup · max-peer safeguards · reconnect + ICE restart handling · recording upload endpoint with signed private download links · health route for deploy probes.

The result is a reliable small-group video system that feels instant for real-world calls while still demonstrating production-grade realtime engineering decisions.

Mesh topology is ideal for small rooms but not large meetings; moving to SFU (mediasoup/LiveKit) is the next scaling step. In-memory room state should move to Redis for multi-instance deploys. Persistent object storage should replace local recording disk on ephemeral hosts. A host 'kick participant' and 'lock room' flow would complete moderation controls.