Mayank Sharma

I'm a full-stack engineer who builds things end-to-end — from FastAPI backends and React dashboards to Docker-based infrastructure and LLM pipelines. My focus is on developer tooling, AI-integrated systems, and backend architecture that holds up under real conditions.

I don't just follow tutorials. I pick problems I actually want solved — a self-hosted AI OS that handles my WhatsApp and Gmail, a hyperlocal emergency-response network for blood and critical medicine, a RAG tool that makes any GitHub repo instantly queryable. Then I build them, break them, and figure out why.

I contribute to open source when I find something genuinely worth fixing — production ML libraries and, more recently, React Native itself. I'm currently going deep on Rust, system design, and Linux internals — not because they're trendy, but because understanding systems at that level makes every other layer of the stack make more sense.

"Understand the system one layer below the one you're working in."

Project	What it does	Status
🩸 LifeLine	Hyperlocal emergency blood/critical-medicine availability network — MERN, OpenRouter-powered AI
🔍 Codebase Q&A	RAG-based tool answering natural-language questions about any GitHub repo, with file-level citations
🤖 METHER OS	Self-hosted AI OS — voice, WhatsApp, Gmail, calendar, local LLM routing

A hyperlocal emergency network connecting people in urgent need of blood or critical medicine with nearby availability — built as my flagship Kalvium end-of-term project, with a heavy system-design emphasis.

The problem it solves: Finding blood donors or critical medicine in an emergency is often a frantic, ad-hoc process of phone calls and WhatsApp forwards. LifeLine turns that into a structured, searchable, hyperlocal network.

Key decisions:

• MERN stack, chosen as a project constraint to keep the stack familiar while the system design does the heavy lifting
• AI integrated via OpenRouter rather than locking into a single vendor, keeping model choice flexible
• Built with strong architecture documentation (HLD, LLD, PRD) to hold up under an AI-conducted technical viva

Paste a GitHub repo URL, ask natural-language questions about the codebase, get answers with file-level citations — powered by a RAG pipeline built from scratch.

The problem it solves: Getting oriented in an unfamiliar codebase is slow. Codebase Q&A lets you interrogate a repo directly instead of manually spelunking through files.

Architecture decisions:

• Manual RAG pipeline — deliberately not using LangChain initially, to actually understand the retrieval pipeline rather than abstract it away
• Supabase Postgres + pgvector for the vector store, Ollama for local LLM + embeddings
• Tree-sitter planned for code-aware chunking rather than naive text splitting
• Own session + refresh-token auth implementation rather than reaching for a managed auth provider
• Built with a 4-person team: I own the RAG/embeddings/pgvector pipeline end-to-end, with teammates owning backend infra+auth and frontend

A self-hosted personal AI operating system. Not a wrapper around ChatGPT — a real orchestration platform running on local hardware with 14 integrated tools.

The problem it solves: Managing async life (messages, emails, meetings, reminders) across 5+ apps is cognitively expensive. METHER OS routes all of it through a single orchestration layer with persistent context.

Architecture decisions:

• FastAPI + React 19 + asyncio + EventBus — an event-driven core so tools can react to state changes without tight coupling
• SecurityLevel 0/1/2 system — tiered permissions so higher-risk agent actions (filesystem writes, sending messages) require an explicit trust level
• Local LLM routing — routes queries to the right model based on task type, avoiding unnecessary API costs
• SQLite for persistent memory — chosen over Redis because the access pattern is read-heavy and single-file backup simplicity matters for self-hosted reliability
• Async orchestration across Python + Node.js runtimes — Python handles ML/AI workloads (Whisper STT, Piper TTS, LLM inference), Node.js handles real-time event streams (WhatsApp bridge, WebSocket server)
• Open-sourced under mether-os/mether-core

What I actually built:

• Voice interaction pipeline: Whisper STT → LLM → Piper TTS, under 2s end-to-end on local hardware
• WhatsApp automation: reads, categorizes, and drafts responses with context from memory
• Gmail workflows: automated triage, reply drafting, label management via Google Workspace APIs
• Calendar scheduling: natural language → Google Calendar event creation
• Terminal execution and filesystem operations as agent tools

Roadmap (v2): replacing the current voice orb with an Iron Man-style holographic wireframe figure (cyan wireframe aesthetic).

Contributing to production-grade probabilistic machine learning libraries used in production ML pipelines for forecasting, uncertainty quantification, and distributional prediction — currently pulling 134K+ monthly downloads.

6+ total PRs across documentation, testing, maintenance, and logic fixes.

• PR #57487 — fixed a decimal-parsing bug in transformOrigin, merged into react-native:main and tagged "Shared with Meta"

Working in production OSS codebases with strict CI, pre-commit hooks, and maintainer review is a different discipline than solo projects. Every PR has to justify itself, pass automated checks, and survive a real code review. The bar for "good enough" is higher, and that's the point.

Languages

Frontend

Backend

Databases & Infra

AI / ML Tooling

Tools & Platforms

Rust
├── Ownership & borrowing model (in progress)
├── Systems programming patterns
└── Goal: write a small CLI tool from scratch in Rust

System Design
├── Distributed systems fundamentals (CAP theorem, consistency models)
├── Database internals (indexing, query planning, storage engines)
└── Goal: be able to design and critique any system at an interview level

Linux Internals
├── Process management, file descriptors, signals
├── Networking stack (how TCP/IP actually works beneath the socket API)
└── Goal: understand what Docker is actually doing under the hood

AWS Architecture
├── EC2, S3, Lambda, RDS — practical usage
├── VPC networking and IAM patterns
└── Goal: deploy METHER OS to a cloud instance with proper infra

Why these four: Rust and Linux internals are about understanding the layer below what I work in every day. System design is about being able to reason about scale before I build the thing that needs to scale. AWS is just practical — self-hosting is great for learning, but real products live in the cloud.

Note: badges above pull live from the GitHub API and stay up. If you want the richer visual stats/streak graphics back, those come from a third-party renderer that occasionally goes down (402 errors) — self-hosting a copy of it is the permanent fix if that matters to you.

Education

• B.Tech CSE (Software Product Engineering) · Kalvium × JECRC University · Expected 2029
• Focus: full-stack development, backend systems, AI-integrated applications, scalable software engineering

Achievements

Leadership

• Team Lead, Smart India Hackathon 2025 — Led multidisciplinary team through problem definition, technical architecture, frontend/backend split, and evaluation presentation

I'm open to internships in:

• Backend engineering (Python, Node.js, distributed systems)
• Full-stack development (React + any serious backend)
• Developer tooling or AI infrastructure

I work well in teams that move fast, have high standards for code quality, and aren't afraid to go deep on hard problems. I'm not looking for a place to coast — I want to work on things that are actually difficult.