Junaid Shaikh

Aug 2023 – Mar 2024

Discord-like Chat Platform

Distributed real-time communication platform

Architected a distributed real-time communication platform supporting servers, channels, direct messaging, media sharing, presence, voice/video calls, and fine-grained role-based authorization. Built as a production-oriented Turborepo monorepo with end-to-end type safety, horizontally scalable messaging infrastructure, and direct-to-object-storage media workflows.

• 01Designed a Redis-backed Socket.IO cluster using pub/sub fan-out, heartbeat-driven presence tracking, and TTL-based offline detection, enabling horizontally scalable real-time messaging with eventually consistent presence across distributed application nodes.
• 02Engineered optimistic messaging through TanStack Query cache synchronization and WebSocket acknowledgements, delivering instant create/edit/delete operations while eliminating polling and redundant API synchronization.
• 03Implemented transactional messaging workflows with cursor-based pagination, deterministic ordering, and authorization enforced at the query layer to guarantee consistency under concurrent user activity.
• 04Built secure direct-to-object-storage uploads using presigned S3 URLs, server-side media validation, upload policies, and OAuth asset re-hosting, completely removing backend file proxying from the request path.
• 05Established compile-time API guarantees across frontend and backend through shared Zod contracts inside a Turborepo monorepo, preventing runtime contract drift and maintaining strongly typed interfaces.
• 06Implemented a hybrid notification pipeline combining Socket.IO for online delivery and Web Push notifications for offline users, using service workers, VAPID authentication, subscription management, and delivery fan-out to ensure users never missed mentions or direct messages.
• 07Containerized the platform using Docker, Nginx reverse proxy, and Grafana Loki centralized logging, providing production-ready deployment, observability, and stateless application services.

Jun 2026

Auditd

Tamper-Evident Multi-Tenant Audit Logging Service

Designed a tamper-evident, multi-tenant audit logging service that provides cryptographically verifiable append-only event storage for compliance workloads, emphasizing deterministic ordering, immutable persistence, and constant-memory verification.

• 01Designed a cryptographically verifiable append-only audit log using chained HMAC-SHA256 hashes across audit records, making unauthorized modification immediately detectable and fully traceable.
• 02Engineered an asynchronous ingestion pipeline using buffered channels, worker pools, exponential backoff retries, bounded queues, and graceful shutdown to guarantee reliable event persistence during service termination.
• 03Enforced immutable storage through PostgreSQL RULEs while coordinating concurrent writes with tenant-scoped advisory locks, preserving deterministic hash ordering without introducing global contention.
• 04Optimized audit retrieval using composite indexes, tenant-aware caching, connection pooling, and multi-dimensional filtering across actors, resources, actions, timestamps, and event types.
• 05Implemented constant-memory streaming exports (CSV/JSONL) and complete audit-chain verification APIs capable of validating historical integrity without loading the entire dataset into memory.

Nov 2023 – Dec 2023

Notion Lite

Collaborative Notion-style workspace

Built a collaborative Notion-style workspace supporting conflict-free real-time editing, live cursors, user presence, recursive document hierarchies, and secure publishing workflows using CRDT synchronization over Cloudflare's edge infrastructure.

• 01Built a collaborative Notion-style workspace supporting real-time CRDT synchronization, live cursors, and user presence using Yjs with Cloudflare Durable Objects for distributed session coordination.
• 02Designed infinitely nested document hierarchies using sixteen Convex serverless functions and composite indexes, enabling recursive archive/restore workflows, orphan-safe re-parenting, and ownership enforcement.
• 03Implemented authenticated editing, secure publishing workflows, public preview routes, and server-side authorization, eliminating unauthorized document modification while maintaining seamless collaboration.
• 04Delivered a feature-rich editor across sixty-plus React components including BlockNote editing, emoji/icon support, cover images, search, responsive layouts, and theme switching while preserving real-time consistency.

Apr 2023 – Jun 2023

Game Explorer

Game-discovery SPA over the RAWG API

A responsive discovery app over RAWG's 880K+ game catalog, with multi-criteria filtering, infinite scroll, and a caching strategy that all but eliminates redundant fetches.

• 01Multi-criteria filtering (genre, platform, sort, search) + infinite-scroll pagination across 25+ components and 11 custom hooks.
• 02Pre-seeded genre/platform lists as TanStack Query initialData with a 24-hour staleTime, so filter sidebars get a zero-network first paint and never refetch within the cache window.
• 03Refactored a prop-drilled tree to a Zustand store + a generic ApiClient<T> over Axios; route-level code-splitting, dynamic SEO, and a multi-stage Docker build (Bun → Nginx).

2024

Go REST API

Learning Go, the systems way

A compact REST API I built to get fluent in Go: clean handler structure, SQL over an ORM, containerized for deployment.

• 01Idiomatic Go service with Gin, hand-written SQL against LibSQL, and a Dockerfile tuned for small images. A deliberate exercise in writing Go that reads like Go.

2025

Redis Rate Limiter

Published npm library · token bucket in Lua

A published npm package that does rate limiting the way it should be done: the entire token-bucket decision runs inside Redis as an atomic Lua script, so every check is a single network round-trip with no race conditions. Drop-in RateLimiter class plus optional Hono middleware.

• 01Token bucket implemented end-to-end in a Redis Lua script: read state, refill by elapsed time, cap, and decrement all happen atomically server-side, which kills the check-then-act race that breaks naive limiters under concurrency.
• 02One EVALSHA call per request: the script is cached in Redis, so each rate-limit check costs a single round-trip regardless of load, designed to sit on the hot path without becoming the bottleneck.
• 03Framework-agnostic RateLimiter core with an optional Hono middleware that returns a clean 429 JSON response; fully typed, configurable maxRequests / windowSizeInSeconds, shipped as ESM via tsup.
• 04Published to npm as @zjunaidz/rate-limiter, so it's installable, documented, and reusable in real projects, not a throwaway demo.