Initializing

Requirements------
API design------
Persistence------
Security------
Deployment------
SunilMaurya sunilmaurya7786@gmail.com

Sunil Maurya

Java backend developer · Azamgarh, India

From the first endpoint to a containerized deploy, and everything that breaks in between.

Available for backend roles

Scroll the story

The journey

How a backend grows: from one endpoint to a full system

0

components

Endpoint

One controller, one response.

Every system starts as a single endpoint. Each layer here is one I have built into a published project, or am building now.

How the work actually happens

At the machine.

01

Think

Understand the problem, the constraints, and what happens when it fails.

02

Design

Shape the system: entities, API contracts, data access, and where to cache.

03

Build

Turn the design into software: Spring Boot services, secured APIs, data layers, and tests.

04

Ship

Production is the real test: green tests, a Docker image, a deploy, and an eye on the logs.

05

Evolve

Software is never finished. The architecture has to grow with the product.

Stack

Across
the stack.

The tools behind the systems, grouped the way they show up in a real backend.

    Languages

    01 / 06

    Languages
    Java, JavaScript, TypeScript, SQL, C
    Backend
    Spring Boot, Spring Security, Spring Data JPA, Hibernate, JWT, Node.js
    Data
    PostgreSQL, MongoDB, Redis
    Delivery
    Docker, Maven, Git, Nginx, Postman, OpenAPI
    Testing
    JUnit, Mockito
    AI
    Spring AI, RAG, Embeddings, LLM apps, MCP

    Case studies

    Proof,
    not promises.

    Forged Media Detection

    Taking harmful media down fast, without ever keeping a copy.

    A trust and safety platform that detects deepfakes and explicit images, routes them for human review, and tracks takedown deadlines. Raw media is never stored.

    Built with

    • PyTorchdetection model
    • Springdecision engine
    • Reactreview console

    The challenge

    Harmful media needs a fast, auditable path from detection to takedown, without the platform becoming a store of the very content it removes.

    What I did

    • Paired a PyTorch detector with a Spring Boot decision engine.
    • Routed flagged items into review with takedown deadline tracking.
    • Produced signed reports while keeping raw media out of storage.

    The result

    • Auditable decisions
    • Deadline tracking
    • No raw media at rest

    SEOPulse

    Turning a website crawl into a ranked list of what to fix.

    A full-stack website SEO audit platform. Connect a site, run a crawl, review ranked issues, and download a report.

    Built with

    • Springsecured API
    • Rediscaching
    • JWTauthentication

    The challenge

    An audit is only useful if it is fast to run and clear about priority. Raw crawl data is noise until it becomes a ranked list of issues.

    What I did

    • Designed crawl, audit, and report flows across a React client and a secured Spring Boot API.
    • Used Redis for hot data and PostgreSQL for audit history.

    The result

    • Ranked issues
    • Downloadable reports
    • JWT-secured API

    DevTasks

    A task manager built like a production service.

    A task manager with registration, JWT auth, role-based access, search, filters, and pagination. Packaged with Docker and Nginx.

    The challenge

    Most to-do apps stop at CRUD. The goal was the parts real products need: identity, permissions, and queries that stay fast as data grows.

    What I did

    • Implemented authentication, authorization, and task workflows.
    • Added search, filters, and pagination on MongoDB.
    • Containerized the stack with Docker behind Nginx.

    The result

    • Role-based access
    • Paginated search
    • One-command deploy

    RedisLab

    Making Redis behavior observable instead of magical.

    A Redis internals lab: data structures, streams, locks, rate limits, persistence, and cluster topologies, exercised through Spring Boot.

    The challenge

    Redis is easy to add and hard to reason about. Locks, persistence modes, and clustering only make sense once you watch them fail.

    What I did

    • Built experiments for structures, streams, distributed locks, and rate limiting.
    • Ran persistence and cluster setups in Docker to observe behavior.

    The result

    • Repeatable experiments
    • Cluster topologies
    • Spring Data Redis patterns

    PrithviCore

    Putting soil data and plant health in a farmer's hands.

    An AI-assisted farm monitoring platform with soil analytics, plant image review, weather context, and a live web app.

    The challenge

    Farm data is scattered across sensors, weather, and what the farmer sees in the field. It needs to land in one place that is simple to read.

    What I did

    • Shipped a live web app with sensor-oriented soil analytics.
    • Added AI-based plant image review with weather context.

    The result

    Earlier studies

    • Resend Mail Server

      A minimal Spring Boot service that sends email through Resend.

      Java
    • School Management

      A Java OOP console project for teachers, students, and grades.

      Java
    • VidyaVault

      A library interface built with HTML, CSS, and JavaScript.

      Web
    • Library Management

      A C console program for adding, issuing, and returning books.

      C
    • PGRKAM AI Career Assistant

      An AI-powered career assistant for career exploration and job-search activities.

      AI

    Right now

    Sometimes I
    break things
    on purpose.

    Labs, experiments, and LeetCode. A different playground for the same backend mindset.

    Currently exploring: Spring AI, RAG, embeddings, MCP, system design, Redis internals, and LLM apps.

    Contact

    What should we build next?

    sunilmaurya7786@gmail.com