Skip to content

About me

I'm Tanay. I build backend systems and the products on top of them.

I'm a Computer Science student at Rutgers University–New Brunswick, minoring in Data Science, and a software engineer at Rutgers' Office of Information Technology.

I'm most interested in backend engineering, distributed systems, and the infrastructure that lets software scale. What draws me in is the gap between code that works in a demo and code that keeps working with many users, many instances, and dependencies that sometimes fail. That is where the interesting questions are: how two servers agree on a count, what a gateway should do when a service stops responding, and how you find out why one request was slow.

I also care about the people on the other end. The systems I enjoy most are the ones that make something useful possible, whether that's a portal thousands of students rely on or a feed that surfaces the filings worth reading.

Tanay Desai

My journey

Working my way down the stack

My path into software started with a diploma in Information Technology at Shri Bhagubhai Mafatlal Polytechnic, which I completed in 2023. While I was still in that program, I took my first internship, building front-end features at SkillsVista.

After the diploma, I started a B.S. in Computer Science at Rutgers University–New Brunswick, with a minor in Data Science, and I expect to graduate in May 2027. A few months into my first year, I joined Rutgers' Office of Information Technology as a software engineer, which meant learning in class and on a production codebase at the same time.

Looking back, my work has moved steadily toward the backend. I started on the front end, spent my time at Rutgers building shared React components and untangling state management, and then spent a summer working on Java microservices, data integrity, and cloud infrastructure at Vertex. My personal projects have followed the same direction, each one going a little deeper into how services coordinate, fail, and recover.

Rutgers University, New BrunswickB.S. Computer Science, minor in Data Science
Sep 2023 – May 2027
Shri Bhagubhai Mafatlal PolytechnicDiploma, Information Technology
Dec 2020 – Jun 2023

Experience & growth

What the work has taught me

Rutgers OIT

Software Engineer
Feb 2024 – Present

At Rutgers' Office of Information Technology, I work with a cross-functional team modernizing the university's central web portal, which more than 70,000 students, faculty, and staff use every day. I build and migrate features onto a React, Redux, and TypeScript architecture, and I've designed more than eight reusable components that are now shared across several internal applications.

Working at that scale changed how I think about small decisions. A component used on one page is a detail; a component used across many applications is a contract. Improving the accessibility of shared components for students who use assistive technology, and refactoring Redux data flows to fix recurring state bugs, showed me that reliability is something users feel directly, not only something measured on a server.

Vertex Inc.

Software Engineering Intern, Backend
Jun – Aug 2026

At Vertex, I spent the summer of 2026 on the backend, working in distributed Java and Spring Boot microservices. I remediated 18 security vulnerabilities, including a critical improper-authentication flaw, by upgrading dependencies and validating the fixes across a multi-repository Gradle build. I also patched a soft-delete bypass that let deleted records leak into downstream flows, fixed a production data-integrity bug caused by a write that was missing across related records, and migrated AWS S3 buckets to standalone Terraform lifecycle, versioning, and CORS resources.

The common thread was that the hardest problems rarely lived in a single line of code. They sat between services, between related records, and between what the configuration said and what actually ran in production.

SkillsVista

Front End Engineering Intern
Jul – Aug 2022

My first internship was on the front end at SkillsVista, during the summer of 2022, while I was still completing my diploma.

None of this was solo work. At Rutgers I build with a cross-functional team on a shared codebase, and at Vertex my fixes had to be validated across several repositories before they could ship. Both taught me to write changes that other people can review, test, and build on, and to explain why a change matters, not just what it does.

What I enjoy building

Systems that stay correct under load

The projects I enjoy most are the ones where the hard part isn't visible on the screen. I like working on rate limiting, routing, event pipelines, and observability: the pieces that decide whether an application is fast, fair, and dependable once real traffic shows up.

Correctness under concurrency

I like problems where many requests arrive at once and the answer still has to be right. In QuotaForge, per-tenant quotas are enforced with atomic Redis Lua scripts, and usage is metered through an idempotent pipeline so nothing is counted twice.

Systems that fail gracefully

Services go down, so I want the system around them to keep working. RouteMesh uses circuit breakers, bounded retries, timeouts, and last-known-good configuration caches to stay available when a downstream service or its own control plane has trouble.

Performance you can see

I'd rather measure than guess. My backend projects are instrumented with OpenTelemetry tracing and Grafana dashboards, and I use tools like k6 to put real load on a service and watch how it responds.

Software people actually use

Infrastructure matters because of what it makes possible. SignalWatch ingests corporate announcements, uses Claude to summarize and score them, and streams the important ones to users live, so they spend less time searching and more time deciding.

Inside the build

A closer look at my projects, an idea that shapes how I build them, and a short spoken introduction.

Project gallery

Three projects, three kinds of problems

Each of these projects deals with a different way software behaves under pressure: keeping limits fair when requests arrive at the same time, turning a flood of filings into a few useful signals, and keeping traffic moving when a service fails. Together they reflect what I enjoy most: backend systems where correctness, reliability, and visibility matter.

Screenshot of the QuotaForge dashboard listing three tenants, each with a request limit, a 60-second window, and a usage bar.

Distributed systems

QuotaForge

The QuotaForge dashboard, where each tenant gets its own request limit and time window. Behind it, atomic Redis Lua scripts keep those limits correct when many requests arrive at once.

Watch

Why one server isn't enough

“Explaining Distributed Systems Like I'm 5” · HashiCorp on YouTube

This talk uses an ice cream truck analogy to show why a single API server struggles under heavy load, and how spreading the work across many trucks, each with its own queue and waiters, lets a system keep up with demand.

I like it because it makes the core idea behind distributed systems easy to hold in your head. The same questions show up in my own work: QuotaForge has to keep many instances agreeing on one count, and RouteMesh has to decide where traffic goes when part of the system is slow or unavailable. Seeing the problem explained this simply is a good reminder that scalable, reliable applications start with a clear picture of where the work goes.

Watch on YouTube

Listen

A short introduction

A spoken introduction, under 40 seconds, to who I am and what I like to build, for anyone who would rather listen than read. The narration uses a synthetic text-to-speech voice (Piper, with its public-domain LJSpeech voice) reading a script I wrote. It is not a recording of my own voice.

Transcript

Hi, I'm Tanay. I'm a computer science student at Rutgers University, and I enjoy building software that solves interesting technical problems.

I am particularly interested in backend engineering, distributed systems, and understanding how applications behave as they grow.

Projects like QuotaForge, SignalWatch, and RouteMesh have given me opportunities to explore challenges involving reliability, performance, and real-time systems.

This portfolio brings together some of the work I've done, the technologies I've explored, and the things I've learned along the way.

Looking ahead

Where I'm headed

I'm finishing my degree at Rutgers and looking for software engineering roles focused on backend and infrastructure work. I want to keep building systems that many people and teams depend on, where performance, correctness, and failure handling are part of the design from the start rather than added later.

I learn best by building. Reading about rate limiting or circuit breakers only goes so far; putting a service under load with k6, or taking down a downstream service on purpose to watch a gateway respond, teaches me things a diagram can't. When something breaks, I try to find where the system's assumptions stopped holding before changing any code. The data-integrity bug I fixed at Vertex wasn't a typo; it was a write that needed to happen in two places and only happened in one.

There is still a lot I want to learn, from how large systems are operated day to day to how teams make good architectural decisions together. If you're working on problems like these, I'd be glad to hear from you.