Skip to content
AN

Inside the Engineering System

Ashish Namdeo

Full-Stack Engineer

Building scalable distributed systems with Java, Python, Spring Boot, Kafka, AWS & React.

500K+
daily orders on Kafka pipelines
100K+
daily active users on schema-driven flows
10K+
daily trips auto-assigned at p99 < 200ms
6+
years shipping production systems
Lambda StartingAUTHJWT · MySQL

Engineer Profile

I design the path a request takes through a system.

6+ years building backend services and full-stack products. M.S. Computer Engineering, California State University, Northridge (GPA 3.7). Open to relocation and remote.

Operating model

I am a software engineer who builds scalable backend systems and full-stack applications. The work that matters is service boundaries, event contracts, failure isolation, and making the request path obvious — in Java, Spring Boot, Kafka, and React.

Production time has been spent on logistics platforms processing hundreds of thousands of daily orders, schema-driven product surfaces for 100K+ users, and independently deployable microservices with JWT, OpenFeign, and Kafka.

Production incidents

How I Debug a Critical Path

When a critical fulfillment flow goes down, I follow a structured process to find the failure quickly and restore the service safely.

  1. 01

    Contain the issue

    First, I stop risky deployments and check the scope of the issue. I want to know whether it is affecting one client, one workflow, or the entire platform.

  2. 02

    Find where it is failing

    I trace the request or event through the system:

    API → Service → Kafka → Consumer → Database → Lambda

    For example, a 502 from an API points me in a different direction than increasing Kafka consumer lag.

  3. 03

    Compare with the last working state

    Next, I check what changed around the time the issue started — a deployment, configuration change, Kafka partition/consumer change, database issue, cache, or an upstream payload.

    I compare error rates, latency, throughput, and Kafka lag with the previous healthy period.

  4. 04

    Trace one failed request

    I pick one failed order or trip and follow its ID through application logs, Kafka events, and downstream services.

    This helps me identify exactly where the request stopped instead of making assumptions based only on the initial error.

  5. 05

    Apply the smallest safe fix

    Once I know the failing component, I focus on restoring the flow first. Depending on the issue, that could mean rolling back a deployment, retrying failed messages, isolating a poison message, or fixing a consumer configuration.

    After the fix, I verify that traffic is processing normally again.

  6. 06

    Prevent the same issue from happening again

    Finally, I document what failed, which signal could have caught it earlier, and what needs to change in the system or monitoring.

    The goal isn't just to fix the incident — it's to make the next occurrence easier to detect and recover from.

Experience
6+ years
Based
Los Angeles, CA
Education
M.S. Computer Engineering, CSUN
Availability
Open to relocation and remote

Experience

A timeline of systems that had to keep running.

Each role is a production environment: orders, trips, APIs, and the incidents that proved the design.

Senior Java Developer

Current

AMI Asset Management · Los Angeles, CA

Sep 2025 – Present

Responsibilities

  • Architected and developed a company-wide Financial Request Management platform using Java, Spring Boot 3, and RESTful microservices, streamlining financial approval workflows across departments.
  • Developed secure REST APIs with Spring Boot and Spring Security, implementing JWT-based authentication and role-based access control for internal users and financial workflows.
  • Modernized legacy Java applications using Java 17 features including Streams, Lambda Expressions, Records, Switch Expressions, Optional, and Spring AOP, improving code maintainability and reducing duplication.
  • Designed event-driven microservices using Apache Kafka across 5+ topics, including financial requests, payments, notifications, audit, and analytics.
  • Designed and optimized data persistence using MySQL, Spring Data JPA, transaction management, indexing, query optimization, and optimistic locking to support concurrent financial workflows.
  • Implemented Redis caching for frequently accessed user data, reducing unnecessary service-to-service communication and database load.
  • Integrated Generative AI capabilities using Spring AI and Amazon Bedrock, implementing RAG-based document retrieval and vector embeddings for context-aware financial information retrieval.
  • Integrated Amazon Bedrock Nova Micro to classify financial documents, extract key fields, and generate structured outputs for automated request processing and approval workflows.
  • Built responsive enterprise interfaces using ReactJS 18, TypeScript, JavaScript, HTML5, CSS3, and Material UI for request submission, document workflows, approval management, and operational dashboards.
  • Containerized microservices with Docker and deployed applications to Amazon EKS, managing AWS infrastructure across development, QA, and production environments.
  • Built automated CI/CD pipelines using Jenkins with automated builds, testing, and deployments to improve release consistency across environments.
  • Implemented unit and integration testing using JUnit and Mockito, validated APIs with Postman, and monitored production systems using Prometheus and Grafana.

Featured System

BookStore Microservices Platform

A scalable e-commerce platform built as independently deployable Spring Boot services, with JWT at the edge, OpenFeign for synchronous calls, and Kafka for domain events.

JavaSpring BootSpring Cloud GatewayOpenFeignApache KafkaJWTMySQLStripeDockerAWSFull system design →

Problem

A monolith cannot isolate auth, catalog-adjacent user data, order lifecycle, payments, notifications, and analytics without coupling release cycles and failure domains.

Solution

Split the platform into focused services behind an API gateway. Keep request/response paths synchronous where consistency is required, and publish domain events so payment, notification, and analytics can proceed independently.

Decisions

Sync where the order cannot be accepted without a consistent read. Async where Stripe, notifications, and analytics would otherwise sit on the checkout thread.

Engineering Lab

The mechanics, not the metaphor.

Small simulations of the same ideas used in the BookStore platform and in production Kafka pipelines.

Partitioning, consumer groups, parallel consumption, and offsets — with records you can step through.

Producer

Each record has a key. Partition = hash(key) % 4. Same key always lands on the same partition, preserving per-key order.

Topic · 4 partitions

P0off 0

P1off 0

P2off 0

P3off 0

Consumer group · 2

One group shares the topic. Each partition is assigned to a single consumer in the group — that is parallel consumption without breaking partition order.

C0

partitions P0, P2

C1

partitions P1, P3

Work

Systems, services, and the decisions behind them.

Each module is a real project. GitHub and live links appear only when they exist.

Flagship

BookStore Microservices Platform

Event-driven e-commerce platform: gateway, JWT auth, OpenFeign, Kafka, Stripe, Docker, AWS.

Problem
Checkout, identity, payments, notifications, and analytics cannot share one release cycle or one failure domain.
Solution
Independent Spring Boot services behind an API gateway. Synchronous OpenFeign where a consistent read is required; Kafka events for everything that can happen after an order is accepted.
Architecture
  • API Gateway routes to Auth, User, and Order.
  • Order publishes OrderCreated to Kafka.
  • Payment, Notification, and Analytics consume independently.
Key decisions
  • Keep payment off the checkout HTTP thread.
  • Separate auth credentials from user profile data.
  • Containerize first; treat AWS as the cloud-ready deployment target.
Spring BootKafkaJWTMySQLOpenFeignStripeDockerAWS

Module

AuthX

Production-style authentication and authorization service with JWT, refresh rotation, RBAC, and Redis revocation.

Problem
Most product backends rebuild the same security foundation before they can ship domain features.
Solution
A Spring Boot starter covering registration, login, JWT access tokens, refresh-token rotation, RBAC, Redis blacklist, rate limiting, and OpenAPI docs.
Architecture
  • Layered Spring Boot service: controller, security, persistence, exception handling.
  • Stateless JWT access tokens with rotating refresh tokens.
  • Redis-backed token blacklist for logout and revocation.
Key decisions
  • BCrypt password hashing and method-level security annotations.
  • Rate limiting and secure headers against brute-force and common web attacks.
  • Environment-based config and Swagger so the service is actually reusable.
JavaSpring BootSpring SecurityJWTRedisMySQLDocker

Module

Pitch Pilot

Real-time AI pitch-coaching web app with sub-second streaming feedback and session analytics.

Problem
Founders get delayed, unstructured feedback on pacing, filler words, and delivery.
Solution
Full-stack investor-simulation app streaming speech-to-text over WebSockets, with GPT-4o structured feedback and exportable session reports.
Architecture
  • WebSocket streaming path for low-latency transcript and coaching events.
  • Session analytics dashboard with exportable reports.
  • Live demo deployment with documented design tradeoffs.
Key decisions
  • Stream partial results instead of waiting for a full recording.
  • Structure model output so pacing and filler-word metrics are comparable across sessions.
WebSocketsGPT-4oReactPython

Module

AutoFix Agent

Autonomous code-repair agent that plans a fix, runs tests in Docker, and iterates until tests pass or the budget is exhausted.

Problem
Untrusted LLM-generated patches are dangerous to execute on a host, and one-shot patches usually fail the suite.
Solution
Ingest a GitHub issue, plan a fix, write code, run tests in an isolated Docker environment, read results, and iterate with a hard attempt cap.
Architecture
  • Agent loop: plan → patch → test → observe → retry or exit.
  • Sandboxed Docker execution with resource limits and timeouts.
  • Evaluation suite of 20+ cases with run logging for steps, tool calls, and token cost.
Key decisions
  • Never execute generated code on the host.
  • Cap retries so a failing agent cannot loop indefinitely.
  • Log every step for observability, not just the final patch.
PythonAnthropic APIDocker

Module

Carpool

Ride-sharing platform connecting riders and drivers — Java 21, Spring Boot 3, React, MySQL.

Problem
Daily commuting leaves unused seats and uncoordinated demand.
Solution
Full-stack matching product: register, publish or search rides, request bookings, accept/reject, and rate.
Architecture
  • Spring Boot 3 backend with Spring Security JWT, JPA, and Flyway.
  • React + TypeScript client for rider and driver workflows.
  • MySQL 8 as the system of record.
Key decisions
  • JWT + layered architecture so auth is not mixed into ride matching.
  • Flyway migrations to keep schema changes explicit.
  • OpenAPI/Swagger for a contract the frontend can actually consume.
Java 21Spring Boot 3ReactTypeScriptMySQLFlywayJWT

Module

NetGuardian DPI

Java 17 deep packet inspection engine: PCAP analysis, protocol classification, blocking rules, CLI and web UI.

Problem
Packet captures are opaque without protocol tracing tools or native libraries.
Solution
Pure-Java inspection pipeline that classifies HTTP, DNS, and TLS SNI, applies block rules, and exposes both CLI and a REST/web workflow.
Architecture
  • Multi-module Maven: packet models/decoders, PCAP IO, CLI, REST API with web UI.
  • Classification pipeline for TLS SNI, HTTP Host, DNS, flows, and detected domains.
  • Blocking rules for apps, source IPs, and domains.
Key decisions
  • Implemented in Java to keep local setup portable.
  • Same core engine serves automation (CLI) and analysis (web upload).
Java 17Spring BootMavenPcap4J

Module

Journal App

Java journal for habits, tasks, and growth tracking with secure persistence.

Problem
Personal notes and habits need a structured backend, not a throwaway CRUD demo.
Solution
Spring-based journal API with authentication and Redis-backed support for session/token concerns.
Architecture
  • Java service with Spring Security at the edge.
  • Redis used alongside secure persistence.
Key decisions
  • Treat journal entries as authenticated user data, not an open notebook.
JavaSpring SecurityRedisMaven

Module

HabbitDoc

Flutter habit tracker with Pomodoro focus, AR rewards, and a productivity assistant. SS12 hackathon winner at CSUN.

Problem
Habit apps lose ADHD users when the interface adds friction instead of reducing it.
Solution
Mobile-first productivity app with task simplification, Pomodoro, AR character rewards, and guided prompts.
Architecture
  • Flutter client for cross-platform delivery.
  • Pomodoro timer, AR rewards, progress tracking, and in-app guidance.
Key decisions
  • Reward loops and visual scheduling over dense task lists.
  • Shipped as a hackathon product with frontend and Spring Boot backend contributions.
FlutterDartAR

Module

Raipur Radiance

Warm orange-accented VS Code theme — high contrast, built for long coding sessions.

Problem
Default editor themes are either too dim or too noisy for daily use.
Solution
A VS Code theme with a copper-warm accent and balanced contrast, published on the Marketplace.
Architecture
  • VS Code theme extension packaged for Marketplace distribution.
Key decisions
  • Optimize for contrast and warmth rather than trend palettes.
VS CodeJSON token colors

Technology Ecosystem

A map of the stack, grouped by the job it does.

Not a laundry list — each cluster is how a production system is actually assembled.

Languages

What the production systems are written in.

  • Java

    Primary backend language

  • JavaScript

    Product UI and Node services

  • TypeScript

    Typed React surfaces

  • Python

    AI/API work at Marketeq

  • SQL

    MySQL, PostgreSQL, query plans

Contact

Let's build something.

Interested in building scalable systems, distributed applications, or solving interesting engineering problems? I am available for software engineering roles.

© 2026 Ashish Namdeo · Full-Stack Engineer

Download Resume