An AI-powered tennis coaching application that analyzes gameplay, tracks progress over time, and generates personalized drills and feedback to help players improve systematically.

A self-hosted mini-PaaS for deploying Docker containers to SSH-accessible remote nodes — no Kubernetes required. Register nodes, define apps with environment variables, and provision managed dependencies (Postgres, Redis, Kafka, Prometheus+Grafana) with connection details auto-injected into linked services. Built with Go, SQLite, React 18, and Tailwind CSS; supports DigitalOcean/AWS node provisioning, GitHub webhook auto-redeploy via GHCR, live log streaming, and a background health reconciliation loop.

A curated DSA interview prep platform that aggregates the top 5 problem lists (NeetCode 150, Blind 75, Grind 75, LeetCode Top 150, Striver's A2Z), deduplicates them down to ~326 unique problems, and reorganizes everything by 20 core solution patterns — Sliding Window, Two Pointers, Topological Sort, DP 1D/2D, Backtracking, and more. Built in TypeScript/Next.js with the argument that interview prep is better organized around transferable algorithmic strategies than data structures.

An automated pipeline that takes any technical video or audio file and generates perfectly time-synced animated visual overlays — flowcharts, bullet-point summaries, code snippets. The pipeline runs: ffmpeg for audio extraction → faster-whisper for local transcription with timestamps → Claude API for technical scene detection and slide generation → Remotion for animated rendering (spring animations, line-by-line code reveals) → ffmpeg for final composition. Entirely local speech-to-text keeps API costs near zero.

A lightweight agent orchestrator in Go that bridges messaging providers (Telegram, Linear) to Claude Code CLI running locally. It fans incoming events from all configured providers into a single channel, invokes the Claude CLI with each message, streams results back in chunks, and maintains session IDs for multi-turn conversations. Project bindings are hot-reloaded from a JSON config every 5 seconds — no restart needed.

A SaaS OAuth integration broker in Go. Configure an external OAuth provider (Google, etc.) once, and fetch tokens for it via a simple REST API from any application — forever. Tusker handles the full OAuth flow, token exchange, and secure credential storage; downstream apps just call the API to get a valid token on demand. Eliminates per-project OAuth plumbing, token refresh logic, and secret management boilerplate.

A mobile-first application focused on delivering fast, lightweight user experiences with a clean product-oriented architecture.

A full-featured job scheduler and cron manager where users define actions triggered at absolute dates, relative offsets, or recurring intervals. The data model is rich: Schedules contain Triggers (managed by a TriggerAllocator and TriggerCreator) which fire Jobs built from JobTemplates with conditional logic and connector integrations. Designed to replace ad-hoc cron setups with a structured scheduling DSL that supports complex pipelining — Go backend with a TypeScript frontend.

A deployment automation tool that streamlines release pipelines and environment provisioning, reducing manual steps in the deploy workflow.

A comprehensive Go boilerplate for building multi-tenant SaaS applications. Covers JWT auth, role-based access control, Stripe billing (Free/Pro/Enterprise plans with webhook handling), project management with account isolation, and database migrations. Ships with hot reload via Air, Docker, a Makefile workflow, and a Go client SDK — a production-grade starting point that stitches together the full SaaS stack without a heavyweight framework.

A minimal reference implementation of a WebRTC Selective Forwarding Unit (SFU) using mediasoup, supporting multiple simultaneous producers and consumers. The WebSocket-based signaling flow covers RTP capability negotiation, WebRtcTransport creation, and producer/consumer setup handshakes. A clean, annotated starting point for building real-time video/audio conferencing infrastructure without a managed service, demonstrating the full mediasoup signaling lifecycle in one small codebase.

An opinionated REST API framework on top of Gin that exposes Go structs as CRUD APIs with minimal boilerplate — define a model, register routes, and get auth and DB access wired up automatically. Follows an MVC pattern with Rails-style lifecycle hooks (BeforeSave, AfterSave, BeforeAction, AfterAction), bringing Rails-like productivity to Go's net/http ecosystem while preserving performance characteristics.

A Go library implementing copy-on-write point-in-time snapshots for in-memory data stores, with minimal impact on read latency and zero additional memory cost until data is actually mutated. The design layers a SnapshotMap buffer over shard threads, coordinated via a Snapshotter and PITFlusher, and supports simultaneous snapshot instances and cross-shard restore — implementing Redis/RocksDB-style snapshot semantics in pure Go without relying on OS-level fork.

A fork/contribution to DiceDB — an open-source in-memory database in Go that extends Redis-compatible commands with query subscriptions. Clients subscribe to a SQL-like query and receive push updates whenever the result changes, rather than polling. Drop-in compatible with Redis tooling (port 7379, Redis CLI/SDKs work out of the box), bridging the gap between a cache and a live-query reactive database.

A from-scratch implementation of logical replication on top of the Raft consensus algorithm in Go, built as a hands-on exploration of the gap between understanding Raft and actually implementing it. The repo is modular — a ReplicationManager coordinates independently-runnable sub-managers (WAL generator, log replication, leader election) — and ships with a test suite that spawns a 3-node cluster on incremental ports with a dummy in-memory WAL generator.

A striped lock data structure in Go — a LockHasher that maintains a fixed array of 1024 LockStore instances and uses FNV-32a hashing to map string keys to lock slots. Dramatically reduces contention versus a single global mutex, mirroring the approach used in Java's ConcurrentHashMap. Includes benchmarks demonstrating the throughput improvement under concurrent access patterns.

A collection of Go micro-benchmarks covering interface dispatch cost (direct struct calls vs. interface calls vs. interface{} type-switch dispatch) and copy-by-value vs. pointer semantics across function calls. A practical reference for making informed performance decisions in Go code where allocation patterns and dynamic dispatch overhead matter.

An organization and team management tool for structuring people, projects, and responsibilities in a single shared workspace.

A drop-in Go database abstraction layer that stores Go objects across multiple backends (SQLite, MongoDB, MySQL, ClickhouseDB, Postgres) with a unified API. Define a Go struct, call FindOne/FindMany/Save, and the adapter handles the rest. Prioritizes getting to persistence fast with minimal boilerplate over SQL expressiveness.

A reusable authentication and authorization service in Go, born from frustration at rewriting user management for every new project. The vision covers token-based auth (session, JWT, OAuth), RBAC protocols (LDAP, RADIUS, SAML), MFA, and time-based access — starting with a clean token auth API layer as the foundation for shared auth infrastructure.

An algorithmic trading system for processing live tick data and executing rule-based strategies, designed for low-latency ingestion and signal generation.

A Go framework for defining event transformation pipelines between Kafka topics using a simple DSL — specify a source topic, a transformation operation, and a destination topic or external system, then chain multiple stages together. A lightweight alternative to Kafka Streams or ksqlDB for teams that want streaming pipeline logic in Go without JVM overhead.

A Go client library for subscribing to real-time stock price feeds from Zerodha's Kite Connect WebSocket API, built around a callback-handler pattern. Users implement a Process(stock *Stock) error interface; the library handles the WebSocket lifecycle, binary protocol decoding, and high-throughput delivery. Benchmarked for latency across 100k ticks — built for latency-sensitive trading data pipelines.

A Kafka-based workflow engine for defining and executing event-driven processing pipelines, with composable stage definitions and reliable delivery semantics.

A Python static analysis tool that, given a file path and an object name (class, function, or variable), traces and extracts all transitive dependencies of that object into a mirrored output folder — preserving the original import hierarchy. It tokenizes the source, resolves cross-module imports recursively, and copies each dependency to the correct relative path until the full closure is captured. Useful for isolating reusable code from large codebases without manually untangling import graphs.

A Change Data Capture (CDC) tool in Go for migrating MongoDB collections between clusters with minimal downtime. Uses a dump-then-oplog-tail strategy: bulk-copies existing documents, records the start timestamp, then tails the oplog from that point to catch all changes until lag is negligible. A self-contained alternative to mongomirror or Atlas Live Migration for cross-cluster replication without vendor lock-in.

A Go reflection utility that decodes any struct into a normalized DecodedResult — a name string and an attributes map — with optional snake_case key conversion. Useful as a foundation for generic serialization, structured logging, or API response shaping where the struct schema is not known at compile time.

A circular (ring) buffer queue in Go that flushes batched messages to a user-provided FlusherFunc based on configurable thresholds: message count, rollover index limit, and time since last flush. The startIdx/stopIdx pointer arithmetic handles wraparound and config is loaded from JSON at startup. A well-commented systems primitive for high-throughput event buffering with controlled, predictable memory usage.

A Kubernetes operator built with kubebuilder that manages a custom TodoList CRD, watches for pods in operator-namespace with matching names, and reconciles the TodoList status accordingly. Demonstrates both standard Reconciler patterns and external event sourcing via Watches with a channel-based source — an intentionally minimal learning artifact for understanding the operator pattern, CRD lifecycle, and bridging external events into the Kubernetes controller runtime.

A Go library that drives parallel HTTP load against a target server entirely from a JSON config file — specifying base URL, auth, cookies, and a list of API endpoints with static or dynamic query parameters. Requests run concurrently via channels and loop continuously until closed. Useful for load testing or automated API exercising without writing bespoke client code for each project.

A lightweight Go REST API server that exposes CSV files as queryable endpoints. Clients POST a list of file or folder paths along with key-value filters, and the server returns matching rows — a minimal HTML/CSS/JS frontend is included. A handy utility for quickly standing up a queryable interface over flat log or data files without spinning up a database.

An order management system for the Zerodha Kite trading platform — programmatic order placement, modification, tracking, and lifecycle management for automated trading workflows.

An HTTP caching reverse proxy in Go that sits between NGINX and a backend application server, maintaining an in-memory response cache keyed per request. On a cache hit it responds directly; on a miss it proxies to the backend, caches the response, and serves it. Also exposes cache invalidation APIs and supports per-route cache-skip config for endpoints that must always hit the backend — a transparent, zero-dependency caching layer that reduces backend load without any application-level changes.