Open to full-time roles

Full-stack developerwith abackend focus.

3+ years building production web apps with the MERN stack. I spend most of my time in Node.js, MongoDB, and GraphQL — designing schemas, writing APIs, and fixing the bugs nobody else wants to touch.

TypeScript & Node.js

MongoDB & GraphQL

REST & API Design

CI/CD & Docker

See My Work Get In Touch

Years Experience

MERN stack, TypeScript-first

Production Apps

Startups & enterprise

GraphQL

& REST APIs

Schema design, resolvers, caching

AWS

& Docker

EC2, S3, CI/CD pipelines

Projects

WhatIbuilt,why,andwhatwashardaboutit.

Backend-Heavy

Channel Manager

Multi-tenant booking sync system

Code

The Problem

Hotels needed to keep room availability in sync across multiple booking platforms. Stale data meant double-bookings and lost revenue.

What I Built

GraphQL API with MongoDB as the primary store. Cron-based sync jobs that poll external OTAs and reconcile availability. Multi-tenant data isolation through compound indexes. Chose embedded documents for rate plans (read-heavy) but references for bookings (write-heavy) to match access patterns.

The Hard Part

Race conditions during concurrent booking updates from multiple sources. Used MongoDB's version field for optimistic concurrency — if two updates conflict, the later one retries instead of silently overwriting. Also had to make sync jobs idempotent so a failure mid-run could resume from a checkpoint.

Node.js

GraphQL

MongoDB

TypeScript

Docker

Cron Jobs

Full-Stack

MoodMate

Mental wellness tracking platform

Code

The Problem

Users needed a private way to track moods over time and understand patterns — not just log entries, but see trends.

What I Built

MERN app with role-based access (user, therapist, admin). Custom RBAC instead of third-party auth because I needed fine-grained control over therapist-patient data boundaries. Mood analytics built with MongoDB aggregation pipelines — keeps computation server-side. Blog module with sanitized markdown.

The Hard Part

Designing the mood data model to support both quick daily entries and efficient trend queries. Settled on date-bucketed documents that MongoDB's aggregation framework can window over without scanning the entire collection.

React

Node.js

MongoDB

Express

TypeScript

JWT

AWS S3

Full-Stack

E-Commerce Platform

Online store with real payment processing

Code

The Problem

Needed a working e-commerce system — not a demo with fake checkout, but real Stripe integration, inventory tracking, and an admin panel.

What I Built

Next.js frontend with SSR for product pages (SEO). Node.js API handling cart, orders, and Stripe webhooks. Used webhooks for payment confirmation instead of client-side callbacks — eliminates bugs where a browser closes mid-payment. Server-side cart state tied to sessions, not localStorage.

The Hard Part

Inventory race conditions during high traffic. Implemented a reservation system: adding to cart creates a time-limited hold, checkout atomically decrements stock with a 'stock > 0' condition in MongoDB. Simple, but it works.

Next.js

TypeScript

Stripe

MongoDB

Node.js

Tailwind CSS

Full-Stack Developer

Enterprise Product Team·2022 – Present

Full-time

Built a Channel Manager system that syncs room availability across booking platforms — handles 5,000+ sync operations daily with cron-based jobs and checkpoint recovery
Migrated REST endpoints to GraphQL for a deeply nested booking/room/rate data model, reducing frontend round-trips by ~60%
Designed MongoDB aggregation pipelines for availability reporting, replacing a manual Excel process that took ~4 hours per day
Introduced TypeScript across the backend codebase, cutting down runtime type errors that were causing ~3 production bugs per month
Implemented optimistic concurrency control for concurrent booking updates — stopped silent data overwrites from multiple OTA sources

Node.js

GraphQL

MongoDB

TypeScript

Docker

AWS

Frontend Developer

Startup / Contract·2021 – 2022

Contract

Built React applications for 3 client projects — responsive, accessible, all shipped on deadline
Created a shared component library with Tailwind CSS that reduced UI dev time by ~40% across projects
Integrated REST APIs and form validation with React Hook Form + Zod — zero client-reported form bugs after launch
Set up CI/CD with GitHub Actions, taking deployments from a 30-minute manual process to a 3-minute automated pipeline

React

TypeScript

Tailwind CSS

Next.js

GitHub Actions

AboutMe

I like building things that work reliably, and I like debugging the ones that don't.

I'm a full-stack developer who gravitates toward the backend. I enjoy the problems that live there — data modeling, query performance, API design, figuring out why something fails silently at 2 AM.

Most of my experience is in the MERN stack with TypeScript. I've built GraphQL APIs with complex resolvers, MongoDB schemas that handle real business logic, and cron jobs that need to be reliable — not just "run and hope."

I care about error handling, clear logging, and writing code that the next person can actually understand. TypeScript everywhere — I've been bitten too many times by untyped code that "worked on my machine."

I'm not claiming to be a system architect. But I think carefully about how my code fits into the bigger picture — what breaks when this changes, what happens under load, and whether this solution will survive the next feature request.

How I Got Here

2021

Started with Frontend

React, component libraries, responsive layouts. Got comfortable with the UI side, then got curious about what happens after the button click.

2022

Moved to Full-Stack

Picked up Node.js, Express, and MongoDB. Built my first production API. Learned schema design by making mistakes and fixing them under pressure.

2023

Backend-Heavy Work

Built a Channel Manager with GraphQL, cron jobs, and multi-tenant data. Started caring more about data modeling and error handling than pixel-perfect UIs.

2024–Now

Growing as an Engineer

Docker, AWS, CI/CD. Building MoodMate as a proper production app — role-based access, analytics, structured error handling. Learning what it takes to ship and maintain.

Education

BSc in Computer Science (2017–2021)

Certifications

AWS Certified Developer – Associate
Meta Full-Stack Developer Certificate
MongoDB for Developers – Engineering Digest

Skills&Expertise

Organizedbyengineeringdomain—notaflatlistoflogos.

Core Engineering

The fundamentals I use every day

TypeScript

JavaScript (ES6+)

React

Next.js

Node.js

Express.js

REST API Design

GraphQL

Backend Systems

Where I spend most of my time

API Architecture

GraphQL Schema Design

Authentication (JWT, RBAC)

Cron Jobs & Background Workers

Error Handling Patterns

Concurrency Control

Data Validation (Zod)

Webhook Integration

Databases

Schema design, query optimization, data modeling

MongoDB

Mongoose ODM

Aggregation Pipelines

Index Optimization

Schema Design Patterns

Data Migration

MongoDB Atlas

Redis (basics)

Infrastructure & DevOps

Shipping code that runs reliably

AWS (EC2, S3)

Docker

CI/CD Pipelines

GitHub Actions

Azure (App Services)

Vercel

Environment Management

Logging & Monitoring

Frontend

Building interfaces that serve the system

React Patterns

Server-Side Rendering

Tailwind CSS

Framer Motion

State Management (Zustand, Context)

Accessibility

Responsive Design

Performance Optimization

Tools & Practices

Process that makes engineering sustainable

Git (branching strategies)

Code Review

Jest & Testing Library

Postman / API Testing

Technical Writing

Documentation

Debugging & Profiling

Agile / Scrum

HowIWork

A few principles that guide how I write code and make technical decisions.

Handle Errors Explicitly

Every external call can fail. I don't rely on generic catch blocks — I think about what specifically can go wrong and handle each case. Silent failures are production incidents waiting to happen.

Design Schemas for How You Read

In MongoDB, the schema is the most impactful decision. I design around actual query patterns — embedded docs for read-heavy paths, references for write-heavy ones, compound indexes that match real filters.

Keep It Readable

The best code is the code someone else can debug at 3 AM. I'll pick a clear approach over a clever one. If I need a comment to explain what something does, I usually rewrite it instead.

Ship, Then Improve

I don't try to build the perfect system upfront. Ship something that works, see how it behaves with real data, then iterate. Most of my best design decisions came from watching v1 break.

LessonsLearned

Mistakes I've made in production and what I do differently now.

The N+1 Query That Slowed Everything Down

Shipped a GraphQL resolver that looked clean but made a separate MongoDB query per item in a list. 200ms for 10 items, 4 seconds for 200. I didn't catch it because I tested with small datasets.

What changed: Now I always profile with realistic data volumes, and I use DataLoader for batching.

The Cron Job That Silently Did Nothing

A booking sync job failed mid-run but exited cleanly — zero error, zero records processed. Took 3 days for a customer to notice stale data. The job 'succeeded' because nothing threw.

What changed: Every background job now logs: records processed, records failed, and duration. Zero records is an alert, not a success.

Schema Change Without a Migration Plan

Changed a MongoDB document shape in production without thinking about existing documents. Old and new shapes coexisted, and the API returned inconsistent data for a day.

What changed: Now I treat every schema change as a multi-step process: add new field with defaults, backfill, then remove the old one.

Let'sTalk

Looking for a backend-heavy full-stack engineer? I'm interested in roles focused on system design, API architecture, and building infrastructure that other developers depend on.

nidhinmohannidhin@gmail.com

For opportunities & collaboration

github.com/Nidhin-mohan

Code & open source

linkedin.com/in/nidhinm

Professional network

Technical Blog

Writing on MongoDB, GraphQL & backend patterns