Kishan Vaghani
Founder & Lead Engineer, ShareCode
📍 Surat, Gujarat, India · B.E. Information Technology
About Kishan
Kishan Vaghani founded ShareCode and writes the engineering deep-dives on this blog. Day to day he ships product code on the Next.js front-end, the Firebase backend (Auth, Firestore, Realtime Database), the Yjs-based CRDT sync layer, and the WebRTC pipeline that runs voice and video for live pair-programming sessions inside the editor.
He holds a B.E. in Information Technology and worked in full-stack JavaScript before starting ShareCode — the usual progression of dashboards, then real-time dashboards, then realising most of the interesting bugs in his stack lived in the sync layer. ShareCode started as a weekend project to fix the latency and feature problems he kept hitting in other collaborative editors. It has been running in production long enough that the posts on this site quote behavior from real users rather than synthetic benchmarks.
The posts he has shipped here are: the WebRTC architecture explainer (SDP, ICE, STUN/TURN, signaling), the Firebase Authentication internals deep-dive (JWT structure, refresh-token flow, persistence modes, custom claims), the real-time sync walk-through (Yjs, state vectors, WebSocket transport), the technical-interview guide, the beginner intro to remote pair programming, and a couple of shorter teamwork posts. Most run 11–16 minutes of reading time, with full code examples and the specific production mistakes the team has hit and recovered from.
His writing focuses on the gap between a working tutorial and code you would actually ship. Most posts on the wider internet teach the happy path: fetch a token, render a list, connect to Firebase. His posts pick up at the failure modes — what breaks when the refresh-token loop has been silently broken for a month, why your video calls work in dev and fall apart with a fifth participant, how a security rule that passes a smoke test still leaks data under a real query pattern.
Outside ShareCode, Kishan reviews technical interviews using the platform, mentors developers earlier in their careers, and reads more distributed-systems papers than the size of the team strictly justifies. You can find his code on GitHub at github.com/kishanvaghani and reach him on LinkedIn at linkedin.com/in/kishanvaghani.
How Kishan writes
“Most developers hit a tutorial after the obvious approach already failed. The job of the post is not to repeat the official docs — it is to build the mental model that lets the reader predict the next problem on their own.”
“Every engineering post here follows the same pattern. Start with the concrete symptom: the actual console error, the actual Firebase rejection, the actual failure that brought you to a search engine. Build up the model layer by layer until the symptom becomes obvious. Then offer the fix, with the trade-offs you accept when you adopt it. The format takes longer to read than a copy-paste recipe, on purpose — the goal is to leave you able to handle the next variant of the problem without searching again.”
What Kishan writes about
The areas Kishan covers in depth on the ShareCode blog
Real-time collaboration and CRDTs
How CRDTs make multi-cursor editing feel instant. Posts cover Yjs specifically: state vectors, the binary update protocol, tombstone garbage collection, awareness state for presence, and the operational differences between CRDTs and OT that decide what kinds of collaboration you can actually build.
WebRTC and low-latency media
The full WebRTC pipeline from signaling through ICE to media transport. Why peer-to-peer still needs a signaling server, when STUN is enough versus when you have to pay for TURN relay, how to back signaling with Firebase without leaking tokens, and the seven failure modes that only show up under real network conditions.
Firebase authentication and security
JWT structure and the refresh-token flow as they actually behave in the Firebase Auth SDK, persistence modes and why the wrong one logs your users out across tabs, custom claims for RBAC without an extra database round-trip, and security-rule patterns that survive an audit.
Next.js and full-stack JavaScript
Architecture choices for Next.js apps that serve both static marketing pages and live, multi-user product surfaces from one codebase. App Router conventions, Server vs Client component boundaries, integrating Firebase without leaking admin credentials, and SEO that holds up when half the site is dynamic.
Technical interviewing
Running structured technical interviews remotely — problem design that tests engineering judgment rather than syntax recall, rubrics that reduce interviewer bias, and how to structure a 60-minute slot so the candidate gets a fair signal on a bad day. Drawn from the format the ShareCode team uses internally.
Born and based in Gujarat, India. Studied Information Technology (B.E.) and worked through the standard full-stack JavaScript path — dashboards, CRUD APIs, then a real-time dashboard that taught him most of what he now knows about state synchronization, mostly by debugging it at 3 a.m. before a customer demo.
ShareCode came out of frustration with existing collaborative coding tools — heavy installs, enterprise pricing for basic features, and latency that fell over the moment users joined from low-bandwidth connections. The first version was a weekend prototype. It has since grown into the product the engineering posts on this site reference directly.
Most engineering time right now goes into the WebSocket sync layer at higher participant counts — the architecture that handled two or three concurrent editors comfortably starts to behave very differently when an interview panel of five plus the candidate all join one room with screen share and voice on. The posts on this site will continue to track that work as it lands in production.
Writing-wise, the next posts in the queue are a deep-dive on how the editor handles offline edits and re-syncs after a dropped connection, a follow-up to the Firebase Authentication post covering the App Check and reCAPTCHA Enterprise migration, and a short retrospective on the architecture calls that did not age well.
Areas of expertise
- Real-time collaboration & CRDTs
- WebRTC & low-latency media
- Firebase authentication & security rules
- Next.js & full-stack JavaScript
- Technical interviewing
Articles by Kishan
17 postsHow a Ronaldo Match Streams to 100 Million Screens: Live Sports Streaming Architecture
An engineering walkthrough of how a live match reaches 100 million viewers at once — capture and encoding, the bitrate ladder, HLS/DASH/CMAF packaging, origin shields, multi-CDN delivery, adaptive bitrate, low-latency video, and the DRM that protects it.
Deterministic LLM Eval Harnesses and Retrieval Over a Codebase
Two production building blocks for AI-assisted development — a deterministic harness that measures whether generated code actually works, and a retrieval layer (embeddings, chunking, context windows) that feeds an LLM only the relevant slice of a large repository.
Catching Plausible-But-Wrong Security Advice From LLMs
Token storage, CSP headers, encryption setups — the specific shape of 'almost right with one parameter wrong' answers from AI assistants, and the verification routine that catches them before they ship.
The Five Ways AI-Generated Code Goes Wrong
Hallucinated APIs, plausible-but-wrong security advice, tests that pass because the model wrote them around its own bug — and the detection moves that catch each one before a PR is merged.
A 30-Line Real-User Monitoring Setup (No Third-Party)
Performance Observer API, sending Core Web Vitals back to a small endpoint, and computing the 75th and 95th percentiles — the minimum implementation that beats Lighthouse for catching real regressions.
The Hydration Tax and How to Pay Less of It
Islands architecture, server components, and selective hydration — what each pattern actually changes about the JavaScript that ships and the timeline the user feels.
Auditing a JavaScript Bundle: The Largest Single Lever
How to run a real bundle audit with Webpack/Vite analyzer, the typical offenders that show up on every production site, and the replacement strategies that shave 100kb+ off first load.
Server vs Client Components: The Boundary in Practice
Next.js App Router examples — when to pass server data through a client component, when context providers need to be client components, and the two-thirds static / one-third interactive page pattern.
Where State Should Live in a Frontend Codebase
The three-layer rule — server state, global client state, local component state — with a rubric for which-goes-where and the refactoring path for codebases that have drifted.
Reading a Stack Trace Together: A Method for Debugging as a Team
Stack traces stop being intimidating once you have a method. A six-step routine for reading any trace — JavaScript, Python, anything — plus how to read one a teammate just pasted into a shared session, so two people debug it faster than one.
WebRTC Architecture Explained for Beginners: SDP, ICE, STUN/TURN, and Signaling
A beginner-friendly engineering deep-dive into WebRTC — how video calling actually works under the hood, what SDP and ICE do, why you need a signaling server even though it's peer-to-peer, and the seven production mistakes that quietly break video apps.
Understanding Firebase Authentication Internals: JWTs, Sessions, Security, and Scaling
An engineering deep-dive into how Firebase Auth actually works — JWT structure, the refresh-token flow, persistence modes, security rules, custom claims, and the seven production mistakes that lock teams out of their own apps.
How Real-Time Sync Works Under the Hood
A technical deep-dive into how ShareCode uses CRDTs (Yjs), Firebase, and WebSocket connections to deliver real-time collaborative code editing.
How to Conduct a Technical Interview Online
A complete guide to conducting effective technical coding interviews online — from choosing the right platform and designing problems to evaluating candidates fairly and avoiding common pitfalls.
Remote Pair Programming: A Complete Intro for Beginners
Brand new to pair programming? Start here. Covers the driver/navigator basics, what tools you actually need, when pairing is worth your time, and how to run your first remote session without it feeling awkward. The follow-up post covers advanced patterns.
7 Benefits of Collaborative Coding for Development Teams
Discover why collaborative coding improves code quality, reduces bugs, accelerates onboarding, and strengthens team communication for development teams of all sizes.
How to Share Code Snippets in Real Time
Learn the step-by-step workflow for sharing code snippets in real time using ShareCode — create, write, share, collaborate, and download.
Get in touch with Kishan
Spotted a factual error or have a suggestion for a topic Kishan should cover? Email directly or use the contact form. Corrections are reviewed by the editorial team and applied within a few business days.