Sahil working on a laptop at a late-night cafe counter

Sahil outdoors at dusk in white over-ear headphones, pines and a deep blue sky behind him

Sahil from behind, facing a shop wall hung with electric guitars under a Fender sign

A block-printed textile in red, yellow and black, patterned with rows of oil lamps

Coders do it better.

A manila folder holding a printed resume

Bangalore

Kozhikode

Resume

Cmmd + EnterCtrl + Enter

Software Developer

Desire is the root cause of sorrow.

Sahil

photographstapecutoutsnotesbadges

Sahil Saleem

A name you can take a shot on

The Zen Portfolio

Atlex Intelligence

Atlex Intelligence

View demo
Institutional intelligence for fragmented software
coming soon

The opportunity

I kept seeing the same pattern in software teams: a pull request, incident, or review teaches something important, then that lesson gets scattered across code, tickets, cloud accounts, and people’s heads. The code survives, but the reasoning behind it does not. The next engineer—or agent—starts from zero and pays again for a lesson the organization already learned. As AI makes writing code cheaper, shared context becomes the real bottleneck.

What I’m building

Atlex is my answer: a governed memory for the software estate that brings together code, infrastructure, changes, incidents, decisions, and outcomes. Instead of simply retrieving old artifacts, it turns evidence into proposed lessons, validates them with people, and promotes the useful ones into reusable knowledge and guardrails. Products like Sift can use that context immediately, then feed their results back into it. The goal is simple: never learn the same software lesson twice.

Sift Code Reviewer

View demo
Code review that reads the whole repository
github
open source

The opportunity

I wanted code review to catch the bugs that matter without becoming another noisy bot teams learn to ignore. Static analysis is precise but literal; it can miss a broken contract that spans files. A one-shot LLM review can reason about intent, but often confuses a hunch with evidence. The gap was a reviewer that could understand the repository and still say, “I checked this.”

What I built

I built Sift as a multi-pass review pipeline, not a single prompt. Static tools establish facts, a generator proposes findings, and a separate critic re-reads the change to confirm or reject them. A whole-PR pass catches the drift that file-by-file review misses. For riskier changes, Sift searches callers and definitions before it speaks; findings are evidence-backed, not speculative. Risk-based routing, content-hash caching, and feedback-driven evaluations then focus cost and attention where they matter most.

Engineer at Siemba

View site
Offensive security, run continuously

The opportunity

Security teams are shipping faster than traditional, periodic penetration testing can keep up. Siemba closes that gap with continuous offensive-security testing across web, API, cloud, and AI attack surfaces—then verifies that remediations actually hold. My part was helping make the AI and scanning systems behind that promise fast, reliable, and economical to run.

What I built

I built the automated test-execution layer around EC2 Auto Scaling Groups, scaling the workers that run security assessments as demand changes instead of keeping a fixed fleet online. The security workflow paired OWASP ZAP with automated browser agents. ZAP handled repeatable application-security checks, while the agents could drive real browser journeys through the product. Together, that made continuous testing feel less like a point-in-time scan and more like an always-on offensive-security loop.

CRDT Editor

View demo
Conflict-free collaborative editing
peak performance

The opportunity

Collaborative editing looks easy until two people type in the same place at the same time. A last-save-wins model quietly loses someone’s work; field locks turn collaboration into taking turns; and character indexes fall apart as soon as an earlier edit shifts every position after it. I wanted an editor where people could work at once and trust that no keystroke would disappear.

What I built

I modelled the document as independently identified characters rather than one shared string. A custom fractional-indexing algorithm gives concurrent inserts deterministic positions, while tombstones keep later positions stable. Each field synchronizes through its own Firebase-backed CRDT, so title, content, and tags can change independently. The result is real-time presence, cursors, batching, undo/redo, and O(log N) insertions and deletions—all without a central merge authority or lost edits.

Intern at Gravystack

View site
Financial literacy, built for families

The opportunity

At Gravystack, I worked on a gamified, gigs-based app designed to help families make financial learning feel practical rather than intimidating. The experience had to feel playful on the surface, but underneath it needed dependable data, integrations, and a backend that could keep pace with the product.

What I built

I worked across the product boundary: the frontend was built in Unity, while I built scalable NestJS + TypeScript APIs behind it. I integrated third-party SaaS services with DynamoDB, used PartiQL, and tuned access patterns around the real queries the app needed to make. That work brought query latency down by 40%, making the backend feel as responsive as the game layer.