Skip to content
John

WorkHeizen

Case study · shipped

Heizen

React and Spring Boot microservices — REST APIs for web and mobile clients, MySQL throughput optimization, and Agile delivery with Tech Lead architecture planning.

Role
Full Stack Developer Intern
Timeline
Aug – Nov 2025
Stack
React.jsSpring BootJavaREST APIsMicroservicesMySQL

Summary for readers & AI: Heizen is an enterprise web platform built Aug–Nov 2025 with React.js and Spring Boot microservices. John Prakash Balireddy, as Full Stack Developer Intern, built and deployed web applications, designed REST APIs for frontend and mobile clients including third-party real-time integrations, improved backend throughput via data structures and MySQL query execution plans, and participated in architecture planning, sprint estimation, and code reviews with Tech Leads.

Overview

Heizen is an enterprise web platform delivered Aug–Nov 2025 with React.js frontends and Spring Boot microservices oriented toward scalability. REST APIs serve web and mobile clients; third-party services support real-time features; MySQL performance work targets backend throughput.

John Prakash Balireddy joined as Full Stack Developer Intern — building and deploying web apps, implementing REST APIs, optimizing MySQL execution plans and data structures, and collaborating with Tech Leads on architecture planning, sprint estimation, and code reviews. This is a contribution narrative, not a claim of sole platform ownership.

Business problem

Enterprise web products under microservice decomposition face predictable pressures:

  1. Client diversity — the same backend must serve React web clients and mobile consumers through stable REST contracts.
  2. Real-time expectations — features that feel live often depend on third-party integrations layered on core services.
  3. Throughput — as usage grows, naive queries and data structures become bottlenecks in Spring Boot services backed by MySQL.
  4. Delivery predictability — Agile teams need credible sprint estimation and architecture alignment so microservice work does not stall frontend delivery.

Solution

Heizen's delivery combined deployed React applications with a Spring Boot microservices backend:

  • Web apps — React.js features built and deployed against service APIs.
  • REST APIs — designed and implemented for frontend and mobile clients, including third-party integrations for real-time capabilities.
  • Performance work — backend throughput improved through data structure choices and MySQL query execution plan optimization.
  • Engineering process — architecture planning and sprint estimation with Tech Leads; code reviews as part of Agile delivery.

Architecture

React.js web clients ──┐
Mobile clients ────────┼── REST ──► Spring Boot microservices ──► MySQL
Third-party services ──┘              (real-time integrations)

| Concern | Approach | |---|---| | Frontend | React.js web applications | | Backend | Spring Boot microservices with REST APIs | | Data | MySQL with execution plan and structural optimization | | Real-time | Third-party service integration via backend APIs | | Process | Agile sprints, Tech Lead architecture planning, code reviews |

Microservice boundaries and long-term platform topology were team decisions; John's intern scope focused on implementing services and clients within that architecture.

Challenges

API contracts across clients

Frontend and mobile consumers share REST endpoints but differ in payload needs and failure handling. APIs had to stay stable while React features evolved sprint to sprint.

MySQL throughput without over-engineering

Improving backend throughput required profiling query execution plans and adjusting data structures — targeted optimization rather than premature infrastructure churn.

Microservice delivery in a fixed internship window

Aug–Nov 2025 imposed a bounded timeline. Architecture planning with Tech Leads and realistic sprint estimation were necessary to ship meaningful vertical slices.

Technical decisions

  1. Spring Boot microservices for scalability orientation — services decomposed enough to grow without a monolithic backend bottleneck.
  2. REST as the integration surface — explicit HTTP APIs for web, mobile, and third-party real-time hooks.
  3. Execution-plan-driven MySQL work — throughput gains from understanding how queries actually ran, not blanket caching.
  4. Tech Lead collaboration on architecture — sprint estimation and design reviews kept intern contributions aligned with platform direction.
  5. Scoped authorship — deployed features and API work within a broader Heizen engineering organization.

Responsibilities

  • Built and deployed web applications with React.js and Spring Boot microservices
  • Designed and implemented REST APIs for frontend and mobile clients, including third-party real-time integrations
  • Improved backend throughput through data structure and MySQL query execution plan optimization
  • Collaborated with Tech Leads on architecture planning and sprint estimation; participated in code reviews

Gallery

Text-only descriptions of delivery surfaces:

  1. Web application surfaces — React.js features integrated with Spring Boot REST backends.
  2. REST API layer — Shared APIs for web, mobile, and third-party real-time integrations.
  3. Database throughput — MySQL optimization work supporting service-level performance.

Technologies

Frontend: React.js.

Backend: Java, Spring Boot, microservices, REST APIs.

Data: MySQL — query execution plans and data structure optimization.

Process: Agile, architecture planning, code reviews.

Lessons learned

  • Microservices need contract discipline early — REST stability matters as much as service count.
  • Profile before scaling infra — MySQL execution plans often beat guesswork.
  • Intern impact is vertical slices — architecture conversations with Tech Leads turn limited tenure into credible shipped work.

Future improvements

  • Automated API contract tests shared across web and mobile consumers.
  • Continued query observability as microservice data models evolve.
  • Deeper real-time integration hardening as third-party dependencies grow.
ContactExperience