Samir Adhikari

Systems-Minded Full Stack Developer

Developer working across web delivery, backend systems, and lower-level data-structure-heavy programming, with a growing focus on storage engines and systems internals.

Short Manifesto

A systems-minded developer who ships full-stack products, then keeps digging deeper into how data structures, storage, and runtimes work under the hood.

Numbers

12

Projects

20

Tools / Skills

4+

Years

What I Bring

A quick overview for recruiters, collaborators, and clients.

</>

full_stack_delivery

Designing and shipping full-stack applications with Next.js, TypeScript, Express, Flask, and practical deployment pipelines. I like owning the whole path from implementation to production.

{ }

backend_systems

Building backend services, APIs, and data flows with an emphasis on correctness, observability, and predictable behavior under real usage.

[ ]

infra_delivery

Handling deployment and operations with VPS hosting, Nginx, release workflows, and CI/CD so projects do not stop at local development.

#

data_structures

Exploring indexing, persistence, and storage internals through systems programming in C, including disk-backed data structures and B+ tree design.

Featured Work

Projects chosen to show the widest range of skills and product work.

All
Developer Utility

Font Converters

A font conversion utility with 8 supported formats, 56 conversion paths, batch processing, multi-format export, subsetting, auto-generated CSS, and privacy-oriented in-memory processing. It is a focused developer-facing utility with a fairly rich feature matrix.

Next.jsDjangoPostgreSQL
View Project
Analytics Platform

OWHeroStats

An Overwatch statistics platform with hero pages, map-based breakdowns, comparison views, and filterable stat slices across ranks, regions, and time windows. It is a data-heavy analytics product backed by large-scale scraping and frequent refreshes of hero statistics.

Next.jsDjangoPostgreSQL
View Project
Learning Platform

Loksewa Tayari App

An exam-preparation platform with subscriptions, practice flows, user progress, dashboards, and a broader authenticated product surface than a typical content site.

Next.jsTailwindCSSNest.jsPostgreSQL
View Project
Real Estate Platform

16 Aana Homes

A full-featured real-estate platform with property discovery, listing filters, agent workflows, and detailed property pages that include utilities like EMI calculation and unit conversion. I handled backend-heavy functionality and supported frontend delivery for a fairly broad product surface.

Next.jsTailwindCSSExpress.jsMongoDB
View Project

Currently Building

Active

B+ tree storage engine in C

Right now I am building a B+ tree storage engine in C and working through persistence, indexing behavior, node layout, and correctness around structural operations.

Selected Story

I've spent the last few years shipping real web products across TypeScript, Express, Flask, Django, Next.js, VPS deployments, Nginx, and CI/CD. That work taught me how to own delivery end to end, from implementation to release.

More recently, my attention has shifted toward systems-level programming. I've been building a disk-persistent key-value store in C and working through the invariants and edge cases involved in a B+ tree implementation. That process is where I feel most engaged: careful design, precise behavior, and understanding why a system works, not just that it works.

I still enjoy product work, especially when it involves architecture, backend design, and performance-sensitive logic, but my long-term direction leans toward storage engines, indexing structures, runtime behavior, and low-level correctness.

Working Style

understand_constraints

I start by reducing a problem to its real constraints: invariants, edge cases, expected load, and where correctness actually matters.

model_before_code

Whether it is a web app or a storage structure, I like to model the behavior first so the implementation follows clear rules instead of guesswork.

implement_precisely

I prefer concrete, implementation-level understanding. That means fewer hand-wavy abstractions and more code that behaves predictably under pressure.

verify_reality

I trust explanation only after it survives real behavior: builds, runtime checks, edge cases, and the annoying scenarios that usually expose the truth.