Full Stack Developer | PWAs, Auth & Backend Architecture

Mandar Deshmukh

Building scalable web applications, PWAs, secure auth, and robust backend systems.

Full Stack Engineer at Hyperface Technologies with a Mechanical Engineering foundation. Crafting high-performance Node.js backend services, PostgreSQL schemas, Redis Cache-Aside pipelines, and production PWAs.

1200+
Practical Coding Hours
Hyperface
Fintech PWA & Cards
Redis & SQL
Cache-Aside & Dynamic SQL
99.9%
Target Systems Reliability
BACKGROUND & PHILOSOPHY

About Mandar Deshmukh

Engineering discipline applied to full-stack web software and scalable backend architecture.

The Engineering Journey

Mechanical Engineering → Full Stack Developer → Scalable Backend Track

My journey began in Mechanical Engineering, where I mastered mathematical modeling, thermodynamics, and rigorous system analysis. That structural mindset translated seamlessly into software engineering when I dedicated 1200+ hours to practical programming and software design.

Today, as a Full Stack Developer at Hyperface Technologies, I engineer production credit card management applications and Progressive Web Apps (PWAs). I take pride in delivering resilient user experiences, zero-regression features, and secure authentication flows.

I thrive on solving complex backend problems: decoupling data layers with the Repository Pattern, enforcing Cache-Aside Redis strategies, and optimizing PostgreSQL queries for high concurrency.

Primary Focus
Fintech & Backend Systems
Engineering Mindset
Clean Code & High Performance

Core Technical Focus

System Design & Architectural Passions
Backend Engineering
Progressive Web Apps (PWAs)
Session Management & Auth Architecture
System Design & Clean Architecture
High Performance Caching (Redis)
PostgreSQL Database Tuning
PROFESSIONAL EXPERIENCE

Work Experience

Engineering high-availability fintech products and Progressive Web Apps at scale.

Hyperface Technologies

Full Stack Developer
Current Role IndiaFull-Time

Architecting and engineering production fintech applications, credit card issuance platforms, and high-reliability Progressive Web Applications (PWAs).

Key Engineering Contributions

Engineered secure authentication systems with token rotation and robust session management.
Developed high-performance Progressive Web Applications (PWAs) tailored for seamless credit card operations and transaction management.
Architected dashboard integrations processing real-time financial metrics and analytics with minimal latency.
Optimized frontend performance, reduced layout shifts, and streamlined state management across micro-frontend views.
Mentored junior software engineers on code quality, clean architecture principles, and TypeScript best practices.
Collaborated closely with cross-functional product and backend engineering teams to ensure 99.9% application reliability.
Technologies:ReactTypeScriptNext.jsNode.jsExpressPWARest APIsReduxTailwind CSS
ENGINEERING CAPABILITIES

Skills & Technical Competencies

Structured skill categories highlighting full-stack engineering and backend architecture mastery.

Backend Engineering

Robust API construction, authorization mechanisms, and robust server architecture.

Node.js(Production)
Express.js(Production)
REST API Design(Advanced)
JWT Authentication(Advanced)
Refresh Token Rotation(Advanced)
Zod Validation(Advanced)
Middleware Architecture(Advanced)
Repository Pattern(Advanced)
Service Layer Pattern(Advanced)
Dynamic SQL & Pagination(Advanced)
bcrypt & Security(Advanced)
11 CapabilitiesProduction Verified

Databases & Caching

Relational data modeling, query optimization, and memory cache layer patterns.

PostgreSQL(Advanced)
Redis Caching(Advanced)
Cache Aside Pattern(Advanced)
Transactions & ACID(Advanced)
Connection Pooling(Advanced)
Dynamic Querying & Sorting(Advanced)
6 CapabilitiesProduction Verified

System Design & Concepts

Foundational concepts for building high-scale, resilient web and backend applications.

Layered Architecture(Advanced)
Horizontal Scaling(Intermediate)
Load Balancing(Intermediate)
API Gateway Concepts(Intermediate)
Rate Limiting & Throttling(Intermediate)
Message Queues(Learning)
Event-Driven Architecture(Learning)
Background Jobs(Intermediate)
8 CapabilitiesProduction Verified

Frontend Craftsmanship

Modern, responsive, and performant user interface engineering.

React.js(Production)
Next.js (App Router)(Production)
TypeScript(Production)
JavaScript (ES6+)(Production)
Tailwind CSS(Production)
Progressive Web Apps (PWA)(Production)
Redux / Toolkit(Production)
React Query(Production)
React Hook Form(Production)
Framer Motion(Production)
Vite & Build Tooling(Advanced)
11 CapabilitiesProduction Verified

DevOps & Tooling

Continuous integration, environment control, and modern delivery workflows.

Git & GitHub(Production)
Docker(Learning)
Vercel Optimization(Production)
CI/CD Workflows(Intermediate)
AWS Fundamentals(Intermediate)
Environment Management(Advanced)
6 CapabilitiesProduction Verified
FEATURED BACKEND SHOWCASE

Backend Architecture Deep-Dive

Inside the Employee Management System: A high-concurrency Node.js API with Layered Architecture, PostgreSQL, and Redis caching.

JWT Token Rotation
Redis Refresh Blacklist
Repository Pattern
Layered Data Isolation
PostgreSQL SQL
Dynamic Filtering & Sort
Cache-Aside Redis
Sub-5ms Query Speed
Layered Architecture & Redis Cache Flow
Node.js / Express / PostgreSQL / Redis
1. Client Request
JSON Payload / Bearer Token
2. Auth & Zod Gate
JWT Token & Payload Contract
3. Service Layer
Business Logic & Invalidation
Redis Cache Hit (<5ms)
FAST PATH

Service layer checks Redis key (emp_list:*). If key exists, cached JSON response is returned directly to the client without querying PostgreSQL.

PostgreSQL Repository SQL
CACHE MISS

Repository executes parameterized SQL with dynamic filters, sorting, and connection pooling. Query result is written back to Redis with a 5-min TTL.

Production Folder Architecture

src/
├── config/
│   ├── db.config.ts          # PostgreSQL Pool & Transactions
│   └── redis.config.ts       # Redis Client Setup
├── controllers/              # Express Request/Response Handlers
├── middlewares/              # JWT Auth, Zod Validation, Error Handlers
├── repositories/             # Decoupled SQL Queries & Data Access
├── services/                 # Business Logic & Cache-Aside Redis Manager
├── types/                    # Zod Schemas & TypeScript Contracts
└── app.ts                    # Server Bootstrap & Middleware Setup

Strict separation of concerns prevents business logic leaks into HTTP handlers or SQL repositories.

src/middlewares/auth.middleware.ts
typescript
Express middleware enforcing double-token auth pattern (Access + Refresh Token rotation) with Redis token blacklist validation.
import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';
import { redisClient } from '../config/redis.config';
import { UnauthorizedError, ForbiddenError } from '../errors/http.errors';

export interface AuthenticatedRequest extends Request {
  user?: { userId: string; role: string };
}

export const authenticateToken = async (
  req: AuthenticatedRequest,
  res: Response,
  next: NextFunction
) => {
  try {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];

    if (!token) {
      throw new UnauthorizedError('Access token required');
    }

    // Check Redis token blacklist for revoked access tokens
    const isBlacklisted = await redisClient.get(`bl_${token}`);
    if (isBlacklisted) {
      throw new ForbiddenError('Token has been revoked');
    }

    const payload = jwt.verify(token, process.env.JWT_ACCESS_SECRET!) as {
      userId: string;
      role: string;
    };

    req.user = payload;
    next();
  } catch (error) {
    next(error);
  }
};
PORTFOLIO SHOWCASE

Featured Projects

Production full-stack applications, credit card platforms, and backend REST APIs engineered for scalability.

CruiseRental
Full Stack
FEATURED

CruiseRental

Enterprise Car Rental Platform & Dedicated Admin Dashboard

Comprehensive car rental application inspired by Avis. Built with React, Redux, Node.js, Express, MongoDB, and TypeScript. Features full customer booking flow, vehicle search, authentication, and a separate administrative portal for fleet management.

Architecture Highlights:
  • Decoupled React frontend and separate administrative portal.
  • RESTful API with session authentication and role-based access control.
ReactReduxTypeScriptNode.jsExpressMongoDBChakra UI
Production Ready
Oasis E-Commerce
Frontend

Oasis E-Commerce

High-Traffic E-Commerce Platform Inspired by ShopClues

Collaborative e-commerce platform built to handle multi-category product catalog browsing, cart operations, user profiles, and simulated multi-step payment gateway integrations.

Architecture Highlights:
  • Component-driven layout architecture with reusable product grid layouts.
  • Local storage sync for persistent shopping carts across reloads.
ReactJavaScriptChakra UIREST APIHTML5/CSS3
Production Ready
Shopetronics
Frontend

Shopetronics

Global Consumer Electronics Storefront Inspired by GeekBuying

Individually engineered e-commerce app focused on tech gadgets and electronics. Built with focus on responsive layouts, filterable product views, price calculators, and checkout flow.

ReactChakra UIJavaScriptREST API
Production Ready
BestReads Platform
Frontend

BestReads Platform

Interactive Literature Discovery & Book Recommendation Portal

Collaborative book exploration platform built to catalog top literature, user reviews, and curated reading lists inspired by IdeaKart.

JavaScriptHTML5CSS3DOM Manipulation
Production Ready
EVOLUTION & PROGRESSION

Learning & Career Timeline

From Mechanical Engineering to Full-Stack PWA craft and scalable backend architecture.

Engineering FoundationsEducation

Mechanical Engineering Degree

Problem-Solving, Mathematical Modeling & Engineering Thinking

Developed strong analytical skills, thermodynamics, fluid dynamics, and structured engineering methodologies. Laid the mindset foundation for analytical problem solving and quantitative reasoning.

Analytical problem solving
Systems thinking
Data & physics modeling
MathematicsPhysicsCAD Modeling
Developer TransitionCareer

Full Stack Web Development Immersion

1200+ Hours Intensive Practical Coding

Dedicated 1200+ hours to intensive web development software engineering principles, building algorithms, data structures, HTML, CSS, JavaScript, and React applications.

Mastered JS fundamentals
Built 5+ full applications
Agile collaboration
HTML5CSS3JavaScriptGit
Frontend MasteryCareer

React & Ecosystem Specialist

State Management, Micro-Frontends & Performance Optimization

Delved into React component architecture, Redux Toolkit state flow, Custom Hooks, and TypeScript integration for scalable client applications.

Reusability
TypeScript type-safety
State isolation
ReactReduxTypeScriptTailwind CSS
Production EngineeringCareer

Full Stack Developer at Hyperface Technologies

Production Fintech PWAs & Credit Card Solutions

Joined Hyperface to build high-stakes fintech products, handling credit card flows, security authentication, and PWA optimization for scale.

Production accountability
Fintech security standards
PWA performance
ReactTypeScriptNode.jsExpressPWA
Backend Deep-DiveBackend Transition

Node.js, Express & PostgreSQL Architecture

Layered Patterns, Relational Modeling & Clean API Design

Expanded core expertise into backend engineering: designing RESTful endpoints, implementing Repository & Service patterns, handling SQL transactions, and strict schema validation with Zod.

Layered architecture isolation
ACID SQL transactions
Zod request contracts
Node.jsExpressPostgreSQLZodJWT
Performance & CachingArchitecture

Redis Cache-Aside & Performance Patterns

Sub-Millisecond Queries & Rate Limiting

Implemented Redis in-memory caching strategies, Cache-Aside pattern, token blacklist management, rate-limiting algorithms, and query latency reduction.

Sub-5ms response speeds
Cache invalidation discipline
Session storage
RedisPostgreSQLConnection PoolingCache-Aside
Next FrontierArchitecture

System Design & Advanced Architecture

Scalable Infrastructure, API Gateways & PWA Security

Actively studying and implementing system design fundamentals: API Gateway patterns, Rate Limiting, PWAs, Session Management, and high-concurrency backend design.

System Design trade-offs
High availability
Fault tolerance
System DesignPWA ArchitectureSession ManagementDocker
GET IN TOUCH

Let's Connect & Build Together

Open for Full Stack Engineering roles, Backend opportunities, system architecture discussions, and technical collaborations.

Direct Email

Preferred channel for inquiries

mandardeshmukh.mud@gmail.com

Send a Message

Directly dispatches to Mandar Deshmukh