Survived 0.0s
I build systems that make invisible things legible — blast physics, attack surfaces, a thousand years of art, a bank's document pile — and I write the specification before I write the code. This page is a scroll-driven stack of the work itself.
The concept — every project below is real, screenshotted live off a running server, not mocked up. Scroll and each one pins to the top of the stack as the next rises to cover it — like flipping through a stack of case files. No parallax library: the stacking itself is position: sticky, one per project; the only scroll-driven code left dims a card once the next one has covered it.
THE BUILD
Before I write a single line of code, I ask:
Why does this need to exist?
Because a feature without a purpose is just another button.
Behind every click… there's a person trying to get something done.
So I don't design for screens.
I design for people.
An idea looks simple. Until you open the door.
My job is to make all that complexity feel like one simple experience.
What if the API dies? What if the user taps twice?
What if 100,000 people arrive tomorrow? What if everything goes wrong?
That's when the real engineering begins.
Software used to wait for instructions.
Now it can understand them.
That's where I believe software is going.
Nothing I build is ever really finished.
Every bug teaches. Every user teaches. Every failure teaches.
The next version is always waiting.
SO, WHAT DO I ACTUALLY DO?
I take an idea
and turn it into something real.
Something people can use. Something that can scale. Something that can survive reality.
Every repository below is real: the reference numbers are derived from commit dates (YYMM.CODE.serial), not invented. Keep scrolling — each project pins to the top of the stack as the next rises over it.
An AI-curated daily newsroom for trading cards, figures and luxury watches — with its own written design system.
An autonomous penetration-testing platform that validates every finding before it reports it.
Production RAG and document intelligence for a bank — then a written audit of its own P0 holes.
A walkable 3D museum where Indian art history sits as a first-class citizen on the world timeline.
Step inside any book — summaries, timelines, mind maps, character graphs and a grounded AI tutor.
Four physics simulators. One HTML file each. No build step, no dependencies, no network.
▶ Run it live — real canvas, this machine
Angular 18 and ASP.NET Core 8 in Clean Architecture — the enterprise half of the range.
An autonomous QA agent that re-verifies reported bugs against live application behavior — never against a commit message.
"Never guess." A bug is marked fixed only when observed application behavior says so — never because a commit exists.
A locked-off clip of a Lamborghini Revuelto, scrubbed frame-by-frame to scroll — scroll down and it assembles itself; scroll up and it comes apart again.
▶ Scroll it together yourself — opens in a new tab
Ten findings, six case files — every note pinned under the project it came out of, not floating on its own.
A thousandfold increase in yield multiplies the damage radius by ten, not a thousand — one exponent covers seven orders of magnitude.
Fallout dose becomes a function of position and time-since-detonation — activity falls ~100× in the first two days (Way–Wigner t^-1.2).
Every active check needs physical evidence — a DB error signature, a reflected payload, real command output — or it's discarded, not downgraded.
Internal-network scanning is a separate, explicitly authorized switch, host-locked with include/exclude rules and a rate limiter in front.
Embeddings, vectors, retrieval and generation are separate modules — each stage independently inspectable and replaceable.
P0 self-reported: no auth on any endpoint, sequential enumerable IDs — scrapeable with a for-loop. Published, not quietly patched.
Verified Wikipedia/Wikimedia data only; in-copyright modern artists become biography nodes rather than invented reproductions.
A focus raycast throttled to ~10×/s fixed perceived smoothness more than any framerate tuning did.
Three marques, three non-overlapping jobs — averaging references produces mud; assigning each a distinct role produces a system.
A bug is never marked fixed because code changed or a commit exists — only because its actual behavior in the QA environment, captured as evidence, says so.
How the work gets made — in two acts.
The shape of the thing gets written down first — what it is, what it looks like, where every number came from — so it can be picked up cold by anyone, including a future me.
Almost every repository ships a PROJECT_BIBLE.md and HANDOFF.md alongside the source, written to be picked up cold.
PROJECT_BIBLE · HANDOFF · AGENTS · CLAUDE — across 5 repositoriesThe visual language gets its own document with named surfaces and roles before a component exists. Reference the token, never hardcode a hex.
DESIGN_SYSTEM.md — every colour tokenisedBlast, thermal and fallout curves cite a published model. ANTARANG uses only verified Wikimedia data.
Model tables in README.mdThen it gets turned on itself — attacked like an outsider, run without its safety nets, and judged on whether the tool actually fit the job or just felt familiar.
IDBI SARTHI ships a full static self-review, graded P0 to P3, most damaging finding written first.
QA_AUDIT.mdBookVerse runs fully without an API key and says so with a badge. Nythera's internal mode is off by default.
Preview-mode fallback · internal mode default-offVanilla canvas physics. Python security tooling. R3F galleries. Next.js RAG. ASP.NET Clean Architecture. A canvas frame-sequence scrubbed to scroll instead of a video element. The range is deliberate.
7 repositories · TS · JS · Python · C# · WebGLThe philosophy behind every system, workflow and decision above — six operational beliefs, not motivational statements.
AI stopped being a feature somewhere around the second project in this range. It's the layer other systems get built on top of — the one that turns a document pile into a bank's RAG tool, or nine findings into a research board. The advantage isn't access to a model anymore. It's knowing how to architect around one.
A one-off build stops paying you back the day it ships. A system — modules that specify, tokens that don't drift, numbers that trace to a source — keeps paying you back every time it's reused, extended or audited. Everything in THE RANGE is built to be picked up cold, including by a future version of me.
The parts of this work a model can't do are the parts worth protecting: deciding what a project is even for, choosing cube-root scaling over an ellipse, knowing which finding to report first. Automation raises the floor. It doesn't replace the judgment call at the top.
Execution got faster; taste didn't get automated with it. A spec that's actually legible, a design token that's actually reused, a self-audit that leads with the worst finding instead of burying it — that's the difference between work that reads as considered and work that reads as generated.
Nine repositories, five languages, one person — because the gap between having an idea and having it running got small enough to stop being a bottleneck. Building fast isn't a shortcut around rigor; the bible and the audit still get written. It's what makes that rigor affordable at this pace.
Nobody on this range shipped as "just a developer." Spec-writer, designer, security auditor, systems thinker, and the person deciding where the AI belongs in the loop — all the same person, on the same repository, in the same week. That convergence is the job now, not a side skill.
Direct answers to what recruiters, founders and collaborators ask most — who I am, what I've built, and how to work with me.
I'm an AI and full-stack engineer based in Pune, India. I build AI-native systems — RAG pipelines, LLM agent loops, autonomous security tooling — and I've spent about four years as a full-stack developer at RamanByte shipping production .NET, SQL Server and Angular software. This site, THE RANGE, is nine of my repositories stacked into one scroll.
I've built four AI systems where the model is load-bearing, not decorative: IDBI Sarthi, Nythera, HallogenAI and BookVerse AI. IDBI Sarthi is production RAG and document intelligence for a bank, followed by a written audit of its own P0 holes. Nythera is an autonomous penetration-testing platform that validates every finding before it reports it. HallogenAI uses eight specialized agents to re-verify reported bugs against live application behavior. BookVerse AI turns any book into summaries, timelines, mind maps and a grounded tutor — with zero API keys required.
I'm a full-stack developer on Classroom+, RamanByte's learning-management platform. I design the ASP.NET Web API and its SQL Server schema, then build the Angular front end that consumes it. Six of those builds are written up on the Experience page: PIBM's A Journal of Management (live, ISSN 2455-8796), the Classroom+ admin, student and faculty apps, the Dada Udyogini Flutter marketplace apps, and the Vidur Industry Connect admin console.
My stack spans AI-native products (Next.js, TypeScript, Python, LLM APIs) and enterprise software (C#, .NET 8, SQL Server, Angular). For AI-native products: Next.js, React, TypeScript and Tailwind; Python and FastAPI for agents; Groq, Gemini and Ollama for models; Prisma or Drizzle on Supabase and Neon for data. For enterprise work: C# and .NET 8, ASP.NET Web API, EF Core and SQL Server behind Angular 16–18 with RxJS and Signals. Around both: Three.js and React Three Fiber for 3D, Flutter for mobile, and AWS S3, Azure, Redis, SignalR and k6 load testing.
Yes — about four years of production software at RamanByte, plus production RAG built for a bank. At RamanByte my code runs for real institutions: PIBM's journal portal is live on the institution's own domain, and the Classroom+ apps were built for the admins, faculty and students who run on them. The personal repositories are where I push into newer ground: agents, security tooling, 3D and simulation.
I write the specification before the code, then try to break what I built. Before any code exists I write down what the thing is, what it looks like, and what "done" means — every repository on this site ships one. Once it's built, it gets attacked like an outsider, run without its safety nets. IDBI Sarthi's self-published P0 audit and Nythera's validated-only findings are that discipline in practice, not a slide about it.
The model is infrastructure, not a plugin bolted onto a finished product. I design the system assuming a model sits inside the loop from day one — IDBI Sarthi's four-stage RAG pipeline keeps every stage independently inspectable and replaceable, and Nythera checks its own findings through an agent loop before reporting them. The model's output is then reviewed and audited like any other engineer's code.
Five kinds of project, each backed by a shipped repository: security you want proven rather than assumed (Nythera); AI that has to understand documents, not just keyword-search them (IDBI Sarthi, BookVerse AI); 3D experiences on the web that are actually walkable (Antarang); enterprise systems in Clean Architecture built to survive a second client (VaultIQ); and QA where "fixed" is verified against live behavior, not a closed ticket (HallogenAI).
THE RANGE is named for its spread: nine repositories across nine domains, built on one discipline. The domains are editorial, security, applied AI, 3D, product, simulation, enterprise platform, QA verification and motion. It's a scroll-driven stack of running work, each project with its real stack and source link, instead of a grid of screenshots.
Email shreyanshkumarsingh208@gmail.com, or start from the Let's Talk page. The most useful first message covers three things: what's actually broken, what you've already tried, and what "done" looks like. Source code for every project is on GitHub at github.com/gamersinghxx-creator.
The instrument rack.