Boston, MA · Open to Work Backend, full stack, systems

Hi, I'm

Samarth Mahendra

Software engineer with experience across product-facing applications, backend systems, and platform infrastructure, with strongest depth in backend and systems.

I like building software that is useful on the surface and well-reasoned underneath, especially where reliability, performance, and product quality all intersect.

Backend platforms Distributed systems Cloud Performance debugging

View Work Get in touch

Journey

2022 Joined Draup and shipped backend systems for a customer-facing intelligence platform.

2023 Led backend development across 100+ APIs, including migrations, bug fixes, and query-path improvements.

2024 Moved to Boston for Northeastern and started building deeper systems projects from scratch.

Now Working on performance debugging research while looking for strong engineering teams to build with next.

Current Habits

A small look at the habits I keep up consistently: practice, shipping, and staying close to the work over time.

— LiveLeetCode problems solved — easy · — medium · — hard

— GitHub contributions SamarthMahendraneu SamarthMahendra-Draup SamarthMahendra — repos · top langs: loading…

About Me

Building software across backend systems, distributed infrastructure, and thoughtful product experiences.

I care about the full arc of engineering work, from how a product feels to how the underlying systems perform under real load.

Boston, MA · backend, systems, full stack

I like building software from the product surface all the way down to the system behavior underneath.

I’m drawn to engineering problems that sit between product needs and system behavior, where the work is not just about shipping a feature, but about making sure the underlying design will continue to hold as things grow. That usually means backend services, APIs, data-heavy systems, and the kinds of debugging and performance work that reveal where the real bottlenecks are.

What motivates me most is being able to move comfortably across layers of a system without treating them as separate worlds. I enjoy building product-facing software, but I’m equally interested in the platform and infrastructure decisions underneath it: how data moves, where latency comes from, how systems fail, and what makes them easier to operate. I think that mix of product awareness and systems curiosity is where I do my best work.

At this stage, I want the site to show breadth without sounding generic. I can work across a lot of areas, but my strongest edge is in backend and systems-oriented engineering, especially when the problem requires learning quickly, reasoning deeply, and contributing to real production-quality work.

Backend systems Distributed architecture Storage engines Production performance

Education

Northeastern University

MS in Computer Science (Jan 2024 – Dec 2025)

Coursework: Programming Design Paradigms, Algorithms, NLP/ML, Database Systems, Mobile Development, Computer Systems, Software Engineering

Dayananda Sagar College of Engineering

BE in Computer Science (Aug 2018 – Jul 2022)

Boston Community

Boston Code & Coffee

Regular attendee and part of a great local builder community centered around side projects, conversations, and code.

Boston AI Meetups

Active participant in Boston-area AI and ML meetups, following how agents and LLM systems are moving into real products.

Capabilities

A systems-first engineering toolkit shaped by backend work, infrastructure thinking, and product delivery.

I care less about collecting tools and more about knowing where they matter: which abstractions hold up in production, which ones fall apart, and how to move comfortably from feature work into system behavior.

How I usually work

I’m strongest when the work touches both product outcomes and the system decisions underneath.

I like the kinds of engineering problems where architecture, debugging, runtime behavior, and developer velocity all intersect. That usually means backend services, data-heavy systems, migrations, performance work, and the glue that keeps teams shipping.

Translate product or systems ambiguity into something buildable.

Design APIs, pipelines, and storage paths that stay reliable under growth.

Profile, debug, and simplify systems when the real bottleneck appears.

Backend Engineering

Python

Node.js

FastAPI

Django REST REST APIs Async I/O

Caching (Redis) API Optimization

Message Queues gRPC & Protobuf

Software Engineering

Java

TypeScript

C/C++

Rust OOP / OOD Data Structures & Algorithms System Design Data Modeling Concurrency Unit Testing TDD

Systems & Performance

Distributed Systems Storage Engine Design Profiling Fault Tolerance Microservices Event-Driven Arch

Apache Kafka Task Scheduling & Runtimes Batching & Prefetching Cache-Aware Design Memory Management

Databases & Data Infra

PostgreSQL

Redis

MongoDB

Elasticsearch Query Planning Data Pipelines

Observability DB Internals MVCC Partitioning

AI & Automation

OpenAI GPT-4o Function-Calling Agents LLM Orchestration RAG/Embeddings

Google Gemini

Automation Async Agents Structured Outputs

Voice Systems

Cloud & Platform

AWS

Docker

Kubernetes

Terraform

CI/CD

OpenTelemetry Distributed Tracing Deployment Autoscaling

Service Mesh

Experience

Experience across production platforms, research systems, and performance-focused engineering.

From shipping backend features at scale to studying system behavior more deeply, each role strengthened how I design, debug, and deliver software.

Mar 2026 - Present

Volunteer Research Collaborator

Prof. Xiang (Jenny) Ren · Khoury College of Computer Sciences, Northeastern University

Contributing to systems research focused on automated performance debugging, bringing a production engineering lens to profiling, bottleneck analysis, and runtime behavior.

Open source C++ Static analysis Dynamic analysis

Current focus Turning slow, opaque systems behavior into actionable performance signals.

Role Research collaboration

Mode Profiling + systems debugging

Lens Production-minded engineering

Context Khoury College, Northeastern

Aug 2022 - Nov 2023

Associate Software Development Engineer

Draup · Bengaluru, India

Worked on a customer-facing intelligence platform, owning backend systems, query infrastructure, API migrations, and observability improvements across business-critical product surfaces.

Backend Python Django REST Jenkins AWS Datadog PostgreSQL Redis Celery Elasticsearch

Visit Company

Dev & Migration 100+ APIs

Performance about 5x faster aggregations

Feature velocity substantially reduced onboarding time

Reliability meaningfully reduced downtime

Impact Built backend systems that improved both product speed and the pace of shipping.

Apr 2022 - Jul 2022

Backend Engineering Intern

Draup · Bengaluru, India

Focused on the fundamentals that make engineering teams faster: caching, observability, and internal knowledge-sharing. This is where I built strong instincts for operational quality and practical performance wins.

Redis caching Datadog Backend performance Developer enablement

Load times 70% faster

Incident response 40% faster

Focus Caching strategy

Team contribution Internal technical talk

Nov 2021 - Sep 2023

Research Contributor

Dayananda Sagar College of Engineering

Built tooling and algorithms for myocardium wall motion and wall thickness mapping from MRI data, combining image processing, domain-specific modeling, and serious optimization work to handle large high-resolution DICOM workloads.

Python CuPy OpenCV DICOM Multiprocessing

Technical highlight Improved processing throughput by roughly 60x with GPU acceleration and concurrency.

Domain Medical imaging

Method Custom wall-thickness algorithms

Scale lever GPU + multiprocessing

Outcome Better fibrosis and motion analysis

Writing

Writing about storage, query planning, infrastructure, and the systems ideas behind reliable software.

I use writing to make technical ideas clearer, especially where performance, architecture, and implementation details quietly shape outcomes.

MongoDB Internals Perf analysis

Zigzagged Deletes: MongoDB TTL Regression Caused by a WiredTiger Cursor Bug

A regression deep dive showing how descending TTL indexes in MongoDB 4.4 became nearly 57% slower, why WiredTiger was zigzagging with redundant cursor probes, and how a small direction-aware patch fixed it.

Read essay

Core question What happens when a storage engine keeps probing in the wrong direction on every delete?

Topic WiredTiger

Theme Perf debugging

Storage Engines 10 min read

Modern Storage Engines

A ground-up look at B-Trees, LSM trees, WALs, and the choices that separate fast databases from fragile ones.

Read essay

Data Systems 8 min read

Rethinking Metadata Indexing in Analytical Data Systems

How modern lakehouses handle file selection and query planning at scale, and why naive approaches break once the number of files becomes the real systems problem.

Read essay

Writing focus

I usually write about systems where hidden implementation details determine performance, reliability, or product feel.

Storage Query planning Infra Runtime design

Projects

Selected projects across systems, infra, AI tooling, and product-facing builds.

The projects below are the strongest signals for how I build: distributed runtimes, storage and data systems, cloud-backed infra, real-time AI workflows, and product experiments with clear user feel.

Distributed systems

Orion: a Ray-style distributed runtime in C++23

A task runtime and scheduler built to explore futures, object references, and distributed worker execution over a layered architecture with gRPC-backed coordination.

C++23 gRPC Scheduling Concurrency Futures

View Code Read Write-up

worker-1 accepted task graph

future<dataset> mapped across distributed nodes

object-ref resolved with scheduler handoff

throughput tuned around task-based execution

System shape Task graph execution with object references and worker orchestration.

Theme Runtime design

Data pipelines

JobHarvestor: distributed job ingestion and analytics

A cloud-native ingestion platform for collecting, classifying, and analyzing job postings at scale, built around queue-driven workers, resilient browser automation, and production observability.

Kafka Kubernetes FastAPI PostgreSQL Prometheus OpenTelemetry

View Code

ingest observe

Pipeline shape queue-driven workers URL dedup + DLQ

Production ops metrics + tracing tens of thousands of postings per day

Why it matters Turns messy, high-volume web data into a system you can actually operate and trust.

Theme Pipeline reliability

Storage engines

ButterDB and lakehouse metadata pruning

Two systems-heavy projects around data access paths: one for persistent key-value storage with WAL and locking, and one for efficient file pruning over large analytical datasets.

B-Tree WAL Buffer pool Metadata indexing Query planning

ButterDB Lakehouse pruning

storage index

B-Tree pages buffer pool WAL durability

Lakehouse pruning range-aware metadata faster file elimination

What connects them Both projects are about reducing waste in the hot path of data access.

Applied AI systems

Real-time voice AI and chat orchestration

A live AI interaction loop built around FastAPI, Redis, Twilio, Celery, and multiple model providers, designed to make voice and chat feel fast, contextual, and production-ready.

FastAPI Redis Twilio Celery OpenAI Gemini

Voice assistant code

Realtime loop Voice input, model response, and orchestration across telephony + backend services.

Theme Live AI infra

ML infrastructure

MLInfra: containerized model serving with Triton

A serving platform for transformer inference using FastAPI, Docker Compose, and NVIDIA Triton, built to explore deployment flow, ONNX conversion, and dependable model delivery on cloud infrastructure.

FastAPI Triton ONNX Docker GitHub Actions GCP

View Code

gateway routed embedding request

triton server loaded ONNX model

compose healthcheck passed on redeploy

remote deploy triggered from GitHub Actions

Serving focus From model conversion to live inference, the whole path is packaged and deployable.

Theme Cloud deployment

Desktop AI experiment

Tiny AI companions above the macOS Dock

A personalized fork of the open-source lil agents project, rebuilt around custom Bitmoji characters so the assistant feels playful without losing utility.

macOS Swift Claude Gemini Copilot AI agents

Visit Project Source Code

Open project demo

Why it stands out Feels like a desktop-native agent instead of another browser chatbot.

Experience Personality + utility

Project archive

Additional builds that still matter, but don’t need full case-study treatment here.

StackOverflow Clone React, Node.js, and MongoDB Q&A platform with votes and reputation. Stock Portfolio Manager Java MVC application with 100+ JUnit tests and portfolio workflows. Secret Hitler AI 5+ GPT-5 agents with bluffing, deduction, and table-talk behavior. More on GitHub Utilities, prototypes, experiments, and smaller full-stack builds.

Contact

If you’re building something ambitious, I’d love to hear about it.

I’m currently open to software engineering opportunities where I can contribute across backend architecture, systems thinking, and product-facing delivery.

Reach out

Let’s talk about roles, projects, or interesting systems problems.

Whether it’s a backend role, a systems-heavy product team, or simply a conversation about engineering, I’m always happy to connect.

Email Samarth View Resume

Type Lab

Switch the site’s voice.

Three font directions that all fit the layout, but each sends a slightly different signal.

Active direction Editorial

Color mode Light