DEV Community: Rakesh Reddy Peddamallu

# Fat Loss Diet Guide (My Reference)

Rakesh Reddy Peddamallu — Tue, 28 Jul 2026 02:50:28 +0000

Goal

Lose fat while retaining as much muscle as possible.
Continue strength training and eat enough protein.

My Daily Targets

Calories: ~2,000 kcal
Protein: 150 g
Fat: 60 g
Carbohydrates: ~185 g

Step 1: Know My Daily Target

Every day, aim to stay close to:

✅ 2,000 kcal
✅ 150 g protein

Protein is the highest priority for muscle retention.

Step 2: Understand Calories

Each macronutrient has a fixed calorie value:

Protein = 4 kcal/g
Carbohydrates = 4 kcal/g
Fat = 9 kcal/g

Example:

25 g protein = 100 kcal
50 g carbs = 200 kcal
10 g fat = 90 kcal

Step 3: Weigh Food

Use a digital kitchen scale.

Weigh foods before eating and track them in:

Healthify
MyFitnessPal
Cronometer

Tracking removes guessing.

Common Food Values

Protein

1 Egg = ~6 g protein
100 g Chicken Breast = ~31 g protein
100 g Fish = ~22–25 g protein
1 Scoop Whey = ~24–25 g protein
100 g Paneer = ~18 g protein

Carbs

100 g Cooked Rice = ~28 g carbs
100 g Oats = ~66 g carbs
Banana = ~27 g carbs

Fats

1 Egg = ~5 g fat
1 tbsp Oil = ~14 g fat
Almonds (30 g) = ~15 g fat

Sample Day

Breakfast

4 Eggs
Oats

Lunch

Chicken
Rice
Vegetables

Snack

Whey Protein

Dinner

Chicken/Fish
Rice
Vegetables

Before Bed (Optional)

Curd or Paneer (if calories allow)

Daily Checklist

☐ Calories around 2,000 kcal

☐ Protein around 150 g

☐ Lift weights

☐ Drink enough water

☐ Sleep 7–9 hours

Weekly Progress

Every morning:

Weigh yourself after using the bathroom.
Before eating or drinking anything.
Wear similar clothing (or none).

Do not judge progress from one day's weight.

Calculate the weekly average.

Healthy fat loss:

0.4–0.7 kg per week

If weight doesn't decrease for 2 weeks, reduce calories by 100–150 kcal/day.

Important Rules

Never crash diet.
Prioritise protein every day.
Keep lifting heavy.
Be consistent rather than perfect.
Trust weekly trends, not daily fluctuations.

The Golden Rule

Calories determine whether I lose fat.

Protein and strength training determine whether I keep my muscle.

If I consistently hit my calorie and protein targets while continuing my workouts, fat loss will happen and muscle loss will be minimised.

# My Body Composition Analysis (15 May 2026)

Rakesh Reddy Peddamallu — Tue, 28 Jul 2026 02:41:32 +0000

Name: Rakesh
Age: 26
Height: 169 cm
Date: 15 May 2026

Overview

This report represents my starting point before several months of consistent gym training.

Although the machine classifies me as a "Fat Muscle" body type, this is actually a good place to begin because I already have a decent amount of muscle. My biggest challenge is reducing body fat while preserving and gradually building muscle.

Current Stats

Height: 169 cm
Weight: 68.3 kg
BMI: 23.9
Body Fat: 27.3%
Fat Mass: 18.7 kg
Muscle Mass: 46.2 kg
Skeletal Muscle: 27.5 kg
BMR: 1441 kcal
Body Score: 66/100

What the Numbers Mean

Weight

68.3 kg

My weight is within the normal range for my height. The issue isn't my weight—it's how much of that weight is fat versus muscle.

BMI

23.9

BMI places me near the upper end of the normal range.

BMI is only a rough screening tool because it doesn't distinguish between muscle and fat, so body fat percentage is much more useful.

Body Fat Percentage

27.3%

This is my biggest weakness.

For men:

10–15% = Athletic
15–20% = Fit
20–25% = Average
Above 25% = High body fat

At 27.3%, much of my muscle definition is hidden.

Fat Mass

18.7 kg

This means nearly 19 kg of my body weight is fat.

Reducing this while maintaining muscle will dramatically improve my appearance.

Muscle Mass

46.2 kg

This is encouraging.

It means I already have a solid muscle foundation.

My focus should be on revealing this muscle by reducing body fat rather than trying to gain weight.

Skeletal Muscle

27.5 kg

Normal range:
26.7–32.7 kg

I'm already inside the healthy range.

This confirms that I don't have a muscle deficiency—I simply need better muscle definition through fat loss.

Water

36.4 kg

Within the healthy range.

Hydration appears normal.

Protein

9.8 kg

Within the healthy range.

This indicates adequate lean tissue.

Bone & Minerals

Bone Mass:
2.7 kg

Mineral:
3.4 kg

Both are within the expected range.

Basal Metabolic Rate (BMR)

1441 kcal/day

This is the approximate number of calories my body burns at complete rest.

My actual daily calorie needs are much higher after including activity.

Machine Suggestions

The machine recommends:

Lose 9.2 kg of fat
Gain 3.7 kg of muscle

This represents an ideal long-term goal rather than something to achieve quickly.

My Biggest Strengths

✅ Healthy muscle mass

✅ Normal skeletal muscle

✅ Healthy hydration

✅ Good foundation for body recomposition

My Biggest Weaknesses

❌ High body fat (27.3%)

❌ High subcutaneous fat

❌ Limited muscle definition due to excess fat

My Goal

Short-Term (3–6 Months)

Reduce body fat below 22%
Preserve all current muscle
Improve strength in compound lifts

Medium-Term (6–12 Months)

Reach 15–18% body fat
Build noticeably larger shoulders, chest, back and legs
Develop visible upper abs

Long-Term

Reach 12–15% body fat
Maintain muscle year-round
Achieve an athletic physique with visible muscle definition

My Strategy

Training

Push–Pull–Legs routine
Progressive overload
Train each muscle group twice per week

Nutrition

High-protein diet (110–150 g/day)
Moderate calorie deficit (300–500 kcal/day)
Mostly whole foods
Stay hydrated

Cardio

Daily walking
Light jogging when appropriate
Increase daily activity instead of excessive cardio

Recovery

Sleep 7–8 hours
Manage stress
Stay consistent

Important Lesson

This report taught me something important:

My problem isn't that I don't have muscle. My problem is that I have too much body fat covering the muscle I already have.

Trying to lose weight as fast as possible would risk losing muscle.

The smarter approach is to lose fat slowly while continuing to build strength.

Future Comparison

This report will serve as my baseline.

When I take another body composition scan, I will compare:

Weight
Body fat %
Fat mass
Skeletal muscle
Muscle mass
Waist size
Strength levels
Progress photos

The goal isn't simply to weigh less—it's to become leaner, stronger, and healthier over time.

B12 Deficiency – Finding the Cause of Malabsorption

Rakesh Reddy Peddamallu — Sun, 26 Jul 2026 12:32:09 +0000

Step 1 – Confirm B12 Deficiency

Vitamin B12
CBC + MCV + Peripheral Smear
Methylmalonic Acid (MMA)
Serum Folate
Iron Studies (Ferritin, Iron, TIBC, Transferrin Saturation)

Step 2 – Check for Intrinsic Factor Problems

Intrinsic Factor Antibody ⭐ (Most important)
Parietal Cell Antibody

Step 3 – Check for Other Absorption Disorders

Celiac Disease Panel
- Tissue Transglutaminase IgA (tTG-IgA)
- Total IgA
Gastroscopy (Endoscopy) with biopsy (if advised by gastroenterologist)

Step 4 – If Symptoms Suggest Other Causes

SIBO Breath Test
Fecal Calprotectin
Colonoscopy (if indicated)
Small Bowel Imaging (if indicated)

Additional Helpful Tests

Vitamin D
TSH (Thyroid Profile)
Comprehensive Metabolic Panel (CMP)

My Testing Priority

Vitamin B12
CBC + MCV
Methylmalonic Acid (MMA)
Intrinsic Factor Antibody
Parietal Cell Antibody
Folate
Iron Studies
Celiac Panel
Gastroscopy (if needed)

Key Point: If B12 intake is adequate (eggs, meat, fish) but deficiency persists, think malabsorption rather than low intake. Start with blood tests before moving to invasive investigations.

Abs Routine (Personal Reference)

Rakesh Reddy Peddamallu — Sun, 26 Jul 2026 11:22:08 +0000

Goal

Build thick abs
Get a visible six-pack
Improve core strength
Train abs like any other muscle
Stay consistent

Frequency

✅ Train 2 times per week

Example:

Leg Day + Abs
Leg Day + Abs

Workout Duration: 15–20 minutes

Workout A

Reverse Crunch

3 Sets × 12–15 Reps
Lift hips off the floor
Slow and controlled

Lying Leg Raise

3 Sets × 10–15 Reps
Keep lower back pressed to the floor
Lower slowly

Plank

3 Sets × 45–60 Seconds
Tight core
Straight body

Hollow Body Hold

3 Sets × 20–40 Seconds
Lower back on the floor
Don't arch the back

Workout B

Bicycle Crunch

3 Sets × 20 Reps
Twist the torso
Don't rush

Flutter Kicks

3 Sets × 30 Seconds
Small controlled kicks

Side Plank

3 Sets × 30–45 Seconds Each Side

Mountain Climbers

3 Sets × 30–40 Seconds
Keep core tight

Weekly Rotation

Week after week:

Session 1

Workout A

Session 2

Workout B

Progressive Overload

Every week:

Add 1–2 reps or
Hold planks 5–10 seconds longer or
Improve form or
Slow down each rep

Never sacrifice form just to increase reps.

Rest Between Sets

45–60 seconds
Up to 90 seconds if needed

Things to Remember

✅ Slow, controlled reps

✅ Feel the abs working

✅ Breathe normally

✅ Focus on quality, not speed

✅ Recover for at least 48 hours before the next ab workout

Nutrition Reminder

Eat enough protein
Stay in a calorie deficit if the goal is visible abs
Drink plenty of water
Sleep 7–9 hours

Biggest Reminder

Train abs to build them.

Lose body fat to reveal them.

No amount of crunches will show a six-pack if body fat is too high. Consistency with training and nutrition is what makes the difference.

15-Minute Daily Routine to Break the Mouth Breathing Habit

Rakesh Reddy Peddamallu — Wed, 22 Jul 2026 01:01:59 +0000

🌅 Morning (5 minutes)

1. Belly Breathing

⏱️ 2 minutes

Lips closed
Inhale through the nose for 4 seconds
Belly expands
Exhale through the nose for 6 seconds

2. Tongue Posture Hold

⏱️ 2 minutes

Lips gently closed
Entire tongue on the roof of the mouth
Breathe only through the nose

3. Slow Nasal Breathing

⏱️ 1 minute

Slow inhale
Slow exhale
Stay relaxed

🚶 During the Day

Nasal Walking

⏱️ 15–20 minutes

Walk at a comfortable pace
Nose breathing only
If you feel short of breath, slow down instead of opening your mouth

⏰ Every Hour (30 seconds)

When you notice you're mouth breathing:

✅ Close your lips

✅ Tongue on the roof of the mouth

✅ Take 5 slow breaths through your nose

🌙 Before Bed (5 minutes)

Belly Breathing

⏱️ 3 minutes

Inhale through the nose
Belly expands
Exhale slowly through the nose

Tongue Posture

⏱️ 2 minutes

Lips closed
Tongue on the roof of the mouth
Relax your jaw
Continue breathing through your nose

Weekly Progress

☐ Less mouth breathing while working

☐ Less mouth breathing while watching TV

☐ Waking up with mouth closed more often

☐ Nose breathing feels more natural

The Complete React Learning Roadmap for Developers with 3–5 Years of Experience

Rakesh Reddy Peddamallu — Tue, 14 Jul 2026 12:48:55 +0000

Every few months, I see the same question:

"I already have a few years of React experience. What's the best way to become an advanced React developer?"

Most roadmaps either start from absolute basics or jump straight into advanced concepts without explaining why you should learn them.

This article is the roadmap I wish I had. It's designed for developers who already know React but want to reach the next level.

Phase 1 – Revisit React the Right Way

Resource: https://react.dev

Don't read React.dev from start to finish.

You already know how to create components and use useState. Instead, focus on understanding React's mental model.

Must Read

1. Thinking in React

Learn how React applications should be designed.

You'll understand:

Component decomposition
Single source of truth
State ownership
Data flow

2. State as a Snapshot

Probably the most important article for understanding React.

It explains why state behaves the way it does.

3. Queueing a Series of State Updates

Understand batching and functional updates.

4. Render and Commit

Learn what React actually does during rendering.

This is the foundation for performance optimization.

5. Keeping Components Pure

Understand why React expects components to be pure functions.

6. Synchronizing with Effects

Learn the correct purpose of useEffect.

7. You Might Not Need an Effect ⭐

This article alone can eliminate many unnecessary useEffects.

8. Lifecycle of Reactive Effects

Understand dependencies, cleanup, and effect execution.

9. Escape Hatches

Learn when to use:

refs
DOM manipulation
imperative APIs

10. Hooks Reference

Read carefully:

useState
useReducer
useRef
useContext
useMemo
useCallback
useTransition
useDeferredValue

11. React Compiler

Understand where React is heading.

12. Server Components

You don't need mastery yet.

Just understand:

Why they exist
Their advantages
Their limitations

Phase 2 – Learn How React Works Internally

Once you understand the APIs, start learning the engine behind them.

Topics

Virtual DOM
Diffing Algorithm
Reconciliation
Fiber Architecture
Scheduler
Concurrent Rendering
Hydration

Resources

React GitHub

https://github.com/facebook/react

Read selected files and discussions—not every line.

Dan Abramov's Blog

https://overreacted.io

Excellent explanations of React's philosophy.

Josh Comeau

https://www.joshwcomeau.com

Outstanding articles on React, JavaScript, CSS, and browser rendering.

Phase 3 – Master State Management

A common mistake is trying to solve every state problem with Context.

Instead, understand that different kinds of state need different tools.

Learn

Context API
useReducer
Zustand
Redux Toolkit
TanStack Query

Resource

TanStack Query Docs

https://tanstack.com/query/latest

You'll learn:

caching
optimistic updates
retries
mutations
invalidation
pagination

Modern React applications rely heavily on these concepts.

Phase 4 – Master Performance

Performance isn't about adding useMemo everywhere.

It's about understanding why components render.

Learn:

React.memo
useMemo
useCallback
Lazy Loading
Code Splitting
Suspense
React Profiler

Profile first, optimize second.

Phase 5 – Learn Modern Routing

Resource

https://reactrouter.com

Study:

Nested Routes
Loaders
Actions
Error Boundaries
Deferred Loading

Modern routing is much more than page navigation.

Phase 6 – Learn Advanced React Patterns

Study these design patterns.

Compound Components
Custom Hooks
Provider Pattern
Controlled Components
Uncontrolled Components
Headless Components
Render Props
Higher Order Components (historical)

These patterns appear in almost every mature React codebase.

Phase 7 – Learn TypeScript Properly

One of the biggest skill gaps among React developers is TypeScript.

Resource

https://www.totaltypescript.com

Focus on:

Generics
Utility Types
Infer
Mapped Types
Component Typing
Hook Typing

Phase 8 – Learn Testing

Resource

https://testing-library.com

Learn:

React Testing Library
User Events
Mocking
Async Testing
Integration Testing

Test behavior, not implementation.

Phase 9 – Learn Accessibility

Accessibility separates good frontend developers from great ones.

Learn:

Semantic HTML
Keyboard Navigation
Focus Management
ARIA
Screen Readers

Phase 10 – Learn Modern React Frameworks

React itself isn't enough anymore.

Choose one framework and learn it deeply.

Recommended:

Next.js
Remix

Understand:

SSR
CSR
SSG
ISR
Server Components

Phase 11 – Learn Browser Internals

Most React problems are actually browser problems.

Study:

Event Loop
Call Stack
Rendering Pipeline
Layout
Paint
Composite
Reflow
Repaint

These concepts explain many UI performance issues.

Phase 12 – Become Better at JavaScript

React is just JavaScript.

Master:

Closures
Prototypes
Execution Context
Event Loop
Promises
Async/Await
Memory Management

A strong JavaScript foundation makes React much easier.

Phase 13 – Read One Premium Course

If you only buy one React course, I'd recommend:

Epic React – Kent C. Dodds

https://epicreact.dev

It's practical, in-depth, and focused on how experienced developers build production-quality React applications.

My Advice

Many developers spend years learning more React APIs.

I think that's the wrong goal.

Instead, focus on four layers:

Learn the API – Understand what React provides.
Learn the Mental Model – Understand why React behaves the way it does.
Learn the Architecture – Build scalable applications with the right patterns and tools.
Learn the Internals – Understand Fiber, reconciliation, rendering, and the browser itself.

Once you understand these layers, React stops feeling like a collection of hooks and starts feeling like a well-designed system. That's the point where debugging gets easier, architecture decisions become more deliberate, and senior-level interviews feel much more natural.

Push Pull Legs

Rakesh Reddy Peddamallu — Thu, 30 Apr 2026 02:23:59 +0000

Given your stats (≈67 kg, ~26% body fat), the goal isn’t just muscle—it’s recomposition: lose fat while gaining muscle. So this plan balances volume, recovery, and progression.

🧠 Philosophy (why this works)

Push/Pull/Legs is popular for a reason:

Push → chest, shoulders, triceps
Pull → back, biceps
Legs → lower body + core
Each muscle gets trained 2x/week → optimal growth

We’ll keep it:

Simple (so you stick to it)
Progressive (so you improve)
Efficient (no junk volume)

📅 Weekly Structure

Day 1 → Push
Day 2 → Pull
Day 3 → Legs + Abs
Day 4 → Rest / Cardio
Day 5 → Push
Day 6 → Pull
Day 7 → Legs + Abs (light)

🔴 PUSH DAY (Chest + Shoulders + Triceps)

1. Bench Press (foundation lift)

4 sets × 6–8 reps 👉 Strength builder

2. Incline Dumbbell Press

3 sets × 8–10 👉 Upper chest (aesthetic shelf)

3. Shoulder Press (Dumbbell or Machine)

3 sets × 8–10

4. Lateral Raises

3 sets × 12–15 👉 Don’t ego lift—strict form

5. Pec Deck

3 sets × 12–15

6. Tricep Pushdown

3 sets × 10–12

7. Overhead Tricep Extension

2–3 sets × 10–12

🔵 PULL DAY (Back + Biceps)

1. Pull-ups / Assisted Pull-ups

4 sets (max reps)

2. Lat Pulldown

3 sets × 10–12

3. Seated Cable Row

3 sets × 10–12

4. Face Pulls (Week A)

3 sets × 12–15

4. Face Pulls (Week B)

Seated Wrist Curl — 2 × 12–15

Seated Reverse Wrist Curl — 2 × 12–15

5. Reverse Pec Deck

3 sets × 12–15

6. Barbell Curl

3 sets × 10–12

7. Hammer Curl

2–3 sets × 10

🟢 LEGS + ABS DAY

1. Squats (king of legs 👑)

4 sets × 6–8

2. Leg Press

3 sets × 10–12

3. Romanian Deadlift

3 sets × 8–10

4. Leg Curl (Hamstrings)

3 sets × 10–12

5. Calf Raises

4 sets × 12–15

6. Plank

3 × 45 sec

7. Hanging Leg Raises

3 × 10–15

8. Cable Crunch

3 × 12–15

⚡ Progression Rule (this is where most fail)

Every week:

Try to increase weight OR reps
Even +1 rep = progress

If you just repeat same weights → no growth
Gym is not attendance-based, it’s progress-based

🥗 Nutrition (quick truth)

You won’t out-train bad eating.

Protein → ~1.6–2g per kg (~110–130g for you)
Slight calorie deficit

* Water, sleep = underrated steroids

complete path to becoming a professional UI engineer

Rakesh Reddy Peddamallu — Tue, 14 Apr 2026 06:55:18 +0000

Here's your complete path to becoming a professional UI engineer, broken down into phases:

Phase 1 — Foundations (2–3 months)

This is non-negotiable ground. Everything else builds on this. Don't rush it.

HTML: Semantic elements, forms and validation, accessibility basics, ARIA roles, the DOM structure, data attributes, meta tags.

CSS: The box model, specificity and the cascade, Flexbox, CSS Grid, positioning (static, relative, absolute, fixed, sticky), units (px, rem, em, %, vh/vw), pseudo-classes and pseudo-elements.

Vanilla JavaScript: Variables, functions, loops, arrays, objects, DOM manipulation, event handling, the basics of async (callbacks → promises → async/await).

Project to build: A fully static multi-page personal portfolio site — no frameworks, just HTML, CSS, and vanilla JS.

Phase 2 — Core JavaScript Depth (1–2 months)

You need to actually understand JS before jumping into React, or you'll be copy-pasting code you don't understand.

Closures, scope, and the this keyword. The event loop and how the browser executes code. Promises and async/await in depth. The Fetch API and working with REST APIs. ES modules (import/export). Array methods: map, filter, reduce, find. Error handling with try/catch.

Project to build: A weather app or movie search app that fetches real data from a public API, displays results, handles loading and error states — all in vanilla JS.

Phase 3 — React & Component Thinking (2–3 months)

React is the industry standard. Learn it deeply, not just the surface.

JSX syntax. Components, props, and state with useState. Side effects with useEffect. Conditional rendering and lists. Lifting state up and prop drilling. useContext for shared state. useRef for DOM access. Custom hooks. React Router for multi-page apps. Fetching data inside components, handling loading and error states.

Project to build: A full CRUD app — something like a task manager or expense tracker — with multiple routes, persistent data via localStorage, and clean component structure.

Phase 4 — Styling Systems & Design (1–2 months)

This is what separates developers who can code from developers who can build beautiful products.

CSS variables and theming. Responsive design and media queries properly. Mobile-first thinking. Tailwind CSS — understand the utility-first approach. CSS Modules for scoped styles. Basic design principles: spacing, typography scale, color contrast, visual hierarchy. Dark mode implementation. How to read and implement a Figma design accurately.

Project to build: Rebuild an existing well-designed website (like Stripe's landing page or a popular SaaS product) as a pixel-faithful clone using React and Tailwind.

Phase 5 — Professional Tooling & TypeScript (1–2 months)

This is what makes you functional in a real team codebase.

TypeScript: types, interfaces, generics, typing React components and hooks. Vite as a build tool — understand what bundlers do. ESLint and Prettier — linting and formatting. npm and managing dependencies. Environment variables. Git beyond the basics: branching, rebasing, pull requests, resolving merge conflicts. Writing readable commit messages.

Project to build: Convert your Phase 3 CRUD app entirely to TypeScript. Fix every type error without using any.

Phase 6 — State Management & Data Fetching (1 month)

Once apps grow, local state isn't enough.

When you need global state and when you don't. Zustand as a lightweight state manager — learn this before Redux. React Query (TanStack Query) for server state — caching, refetching, pagination, optimistic updates. The difference between client state and server state. Basic GraphQL concepts.

Project to build: A more complex app with real API integration — like a GitHub profile explorer or a Hacker News clone — using React Query for all data fetching.

Phase 7 — Performance & Quality (1–2 months)

This is where junior ends and mid/senior begins.

Core Web Vitals: LCP, CLS, FID/INP — know what they measure and how to improve them. Lazy loading images and components with React.lazy and Suspense. useMemo and useCallback — know when they help and when they're overkill. List virtualization for large datasets. Debouncing and throttling. Code splitting and bundle analysis. Using Chrome DevTools to profile and find bottlenecks.

Testing: Unit testing with Vitest/Jest. Component testing with React Testing Library. End-to-end testing with Playwright. The testing pyramid: know what to test at each level.

Project to build: Audit one of your previous projects using Chrome DevTools and Lighthouse. Fix every performance issue you find. Add a full test suite.

Phase 8 — Next.js & Production Thinking (1–2 months)

Most professional React jobs use Next.js or a similar framework.

SSR vs SSG vs CSR — know the tradeoffs deeply. The Next.js App Router. Server Components vs Client Components. Route handlers and API routes. Image optimization. Environment configuration. Deployment to Vercel. SEO basics: meta tags, Open Graph, structured data.

Project to build: A full-stack Next.js app deployed to production — a blog with a CMS, or a SaaS landing page with a contact form backed by a real database.

Phase 9 — Accessibility & Security (ongoing)

Most developers ignore these. Mastering them makes you stand out.

Accessibility: WCAG AA compliance. Keyboard navigation and focus management. Screen reader testing (use VoiceOver or NVDA). Color contrast requirements. Accessible forms, modals, and custom components.

Security: XSS prevention — never trust user input. CORS and why it exists. Authentication patterns: JWT, sessions, OAuth flows. Content Security Policy headers. CSRF basics.

Phase 10 — Collaboration & Career Skills (ongoing)

The skills that actually get you hired and promoted.

Reading other people's code without getting lost. Writing clear pull request descriptions. Giving and receiving code review feedback. Breaking a vague design into a component tree. Estimating tasks (badly at first, then less badly). Communicating blockers early. Writing documentation that future-you will thank present-you for.

Honest timeline

If you study and build consistently (3–4 hours a day): 12–18 months to be genuinely hireable as a junior-to-mid UI engineer. Phases 1–6 get you to hireable. Phases 7–10 get you to strong mid-level.

The single biggest mistake people make is spending too long in tutorial mode and not enough time building real things that break in ways tutorials don't prepare you for. After Phase 2, every phase should be 40% learning and 60% building.

Want me to go deep on any specific phase?

concepts to learn

Rakesh Reddy Peddamallu — Sat, 11 Apr 2026 17:43:29 +0000

🧠 1. JavaScript (your real foundation — React is just a layer)

If this is shaky, everything collapses.

Core concepts

Closures (not definition — real use cases)
Scope chain
Hoisting (functions vs variables vs let/const)
this (call, apply, bind)
Prototypes & inheritance
Event loop (microtasks vs macrotasks)

👉 You should be able to explain:

“Why does Promise run before setTimeout?”

Async mastery

Promises chaining
async/await vs .then
Error handling patterns
Parallel vs sequential execution (Promise.all, etc.)

Advanced JS (this is where mid-level → senior happens)

Debouncing & throttling (implement from scratch)
Deep vs shallow copy
Currying
Memoization
Immutability (why it matters in React)

⚛️ 2. React Core (but deep, not surface level)

Rendering & lifecycle

What triggers re-render?
Parent → child render flow
Reconciliation algorithm (high level is fine)
Keys (why index is bad — but also when it's okay)

Hooks (this is where interviews focus heavily)

useEffect (timing, cleanup, dependency traps)
useState batching behavior
useRef (why it doesn’t trigger re-render)
useMemo vs useCallback vs React.memo

👉 You should clearly answer:

“Why is my useEffect running twice?” (React 18 Strict Mode)

Advanced patterns

Controlled vs uncontrolled components
Compound components pattern
Render props
Higher Order Components (HOC)
Custom hooks (design clean APIs)

⚡ 3. React Performance (high signal topic)

Avoiding unnecessary re-renders
Memoization strategy (not overusing it)
List rendering optimization
Virtualization (like react-window)
Code splitting (React.lazy, Suspense)

👉 Strong answer:

“How do you debug performance issues in React?”

🏗️ 4. State Management (you need opinions here)

Local vs global state
Context API (and its limitations)
Redux (why, when, when NOT)
Zustand / lightweight stores
Server state vs client state (React Query mindset)

👉 You should say:

“I wouldn’t use Redux here because…”

🌐 5. API & Data Layer

REST vs GraphQL (basic tradeoffs)
Caching strategies
Error handling patterns
Request cancellation (AbortController)
Pagination / infinite scroll

🎨 6. Browser & UI Fundamentals (people ignore this and suffer)

Browser internals

DOM vs Virtual DOM
Reflow & Repaint
CSS specificity
Layout systems (Flexbox, Grid)

Performance basics

Critical rendering path
Lazy loading images/components
Debouncing user input (search bars etc.)

🧩 7. System Design (frontend version)

This is your SDE-2 differentiator

You should be able to design:

Dashboard UI (you literally built one — use it)
Chat app (you’re working on it — perfect)
Data-heavy table (filters, sorting, pagination)

Focus on:

Component structure
State flow
API handling
Performance tradeoffs

🧪 8. Testing (at least decent level)

Unit testing (Jest)
React Testing Library
Mocking APIs
Testing user behavior (not implementation)

🔐 9. Auth & Security (VERY underrated)

Since you worked on IAM — use it.

JWT vs session
Token refresh flow
Secure storage (cookies vs localStorage)
XSS / CSRF basics

🧱 10. Architecture & Real-world Thinking

This is where you stand out.

Folder structure
Reusable components
Separation of concerns
API abstraction layer
Microfrontends (you’ve touched this — leverage it)

⚠️ Brutal truth (you’ll appreciate this)

Most 4-year devs:

Know hooks ✅
Can build UI ✅
Cannot explain WHY things work ❌

That’s exactly what interviews test.

🧭 Simple way to check yourself

If you can confidently answer questions like:

“Why does React re-render?”
“How does event loop work?”
“When would you NOT use useEffect?”
“How would you design a scalable table?”

👉 You’re in top ~15%.

💥 My opinion on you (based on your work)

You already have an edge:

Dashboard work
IAM flow
Complex UI

If you package that into clear explanations, you’ll crack strong companies.

If you want next level:
I can give you:

🔥 30 real interview questions (React + JS + design)
🎯 or do a mock interview and expose gaps

Just tell me what you want.

Leetcode - 23. Merge k Sorted Lists

Rakesh Reddy Peddamallu — Mon, 15 Sep 2025 16:29:19 +0000

When working with linked lists, a classic problem you’ll encounter is:

“Given k sorted linked lists, merge them into one sorted linked list and return it.”

This problem is a favorite in interviews (especially LeetCode #23) because it combines understanding of linked lists, divide-and-conquer, and complexity trade-offs. Let’s dive in step by step.

🧩 Problem Breakdown

We’re given k linked lists, each individually sorted. Our task is to merge them into one sorted linked list.

For example:

Input:
lists = [
  1 -> 4 -> 5,
  1 -> 3 -> 4,
  2 -> 6
]

Output:
1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6

💡 Approach

There are multiple ways to solve this problem:

Brute Force: Put all nodes into an array, sort, then rebuild a linked list.

Simple, but sorting all nodes takes O(N log N) time, where N is the total number of nodes.
Not very elegant.

Min-Heap / Priority Queue: Keep all heads of the lists in a heap, repeatedly pop the smallest.

Efficient (O(N log k)) but requires a heap implementation.

Divide and Conquer (our approach):

Repeatedly merge pairs of lists (like merge sort).
Each merge is linear, and we keep halving the number of lists until one remains.
Clean and efficient without extra data structures.

We’ll use divide and conquer here.

🛠 Step 1: Merging Two Sorted Lists

We first need a helper to merge two sorted linked lists. This is like the merge step of merge sort.

const merge_two_lists = (list1, list2) => {
    let dummy = new ListNode();
    let head = dummy;

    while (list1 && list2) {
        if (list1.val < list2.val) {
            head.next = list1;
            list1 = list1.next;
        } else {
            head.next = list2;
            list2 = list2.next;
        }
        head = head.next;
    }

    if (list1) head.next = list1;
    if (list2) head.next = list2;

    return dummy.next;
}

This runs in O(n + m) where n and m are the lengths of the two lists.

🛠 Step 2: Merging K Lists Using Divide and Conquer

We now merge lists pair by pair until only one list remains.

var mergeKLists = function (lists) {
    if (!lists || lists.length === 0) {
        return null;
    }

    while (lists.length > 1) {
        let mergedLists = [];

        for (let i = 0; i < lists.length; i += 2) {
            let l1 = lists[i];
            let l2 = (i + 1) < lists.length ? lists[i + 1] : null;
            mergedLists.push(merge_two_lists(l1, l2));
        }

        lists = mergedLists;
    }

    return lists[0];
};

📊 Complexity Analysis

Merging Two Lists: O(n + m)
Merging K Lists (Divide & Conquer):
- Each round halves the number of lists.
- We perform log k rounds.
- Each node is processed in every merge step, so total work is O(N log k).

Where:

N = total number of nodes across all lists
k = number of lists

Space Complexity

We only use a few pointers and a dummy node.
O(1) extra space (not counting recursion stack if you write a recursive merge).

✅ Key Takeaways

The divide and conquer approach is elegant, efficient, and doesn’t require additional data structures.
Time complexity: O(N log k)
Space complexity: O(1)

If you need even faster performance in practice, a priority queue (min-heap) is often used, especially when k is very large. But for clean code and interviews, this divide-and-conquer approach is a winner.

Leetcode - 427. Construct Quad Tree

Rakesh Reddy Peddamallu — Tue, 09 Sep 2025 16:26:18 +0000

QuadTrees are a fascinating data structure, often used in image compression, spatial indexing, and graphics. In this blog, we’ll solve the LeetCode 427 – Construct Quad Tree problem, step by step.

📌 Problem Statement

You are given an n x n binary grid (only 0 and 1 values).

Your task is to construct a QuadTree based on this grid:

Each node in the tree represents a sub-square of the grid.
If the sub-square contains all the same values (0 or 1), it becomes a leaf node.
Otherwise, it splits into four children:
- topLeft
- topRight
- bottomLeft
- bottomRight

📖 What is a QuadTree?

A QuadTree recursively divides a 2D space into four quadrants.

For example, take this 4x4 binary grid:

The top-left 2x2 block is all 1 → becomes a leaf node.
The top-right 2x2 block is all 0 → another leaf node.
The bottom-left 2x2 block is all 0.
The bottom-right 2x2 block is all 1.

So the root node will split into four leaves.

🛠️ Approach

We’ll use DFS (divide and conquer) to recursively build the tree:

Check if the current sub-square is uniform (all values are the same).

If yes → return a leaf node.
If not → split into four quadrants.

Recursive Subdivision:

Divide the current square of size n into four n/2 quadrants.
Recursively construct the QuadTree for each.

Build the Node:

If it’s a leaf → isLeaf = true.
If not → isLeaf = false and link four children.

✅ Solution Code

/**
 * // Definition for a QuadTree node.
 * function Node(val, isLeaf, topLeft, topRight, bottomLeft, bottomRight) {
 *    this.val = val;
 *    this.isLeaf = isLeaf;
 *    this.topLeft = topLeft;
 *    this.topRight = topRight;
 *    this.bottomLeft = bottomLeft;
 *    this.bottomRight = bottomRight;
 * };
 */

/**
 * @param {number[][]} grid
 * @return {Node}
 */
var construct = function (grid) {

    const dfs = (n, r, c) => {
        let isAllSame = true;
        let firstVal = grid[r][c];

        // check if all values in current n x n block are the same
        for (let i = 0; i < n; i++) {
            for (let j = 0; j < n; j++) {
                if (grid[r + i][c + j] !== firstVal) {
                    isAllSame = false;
                    break;
                }
            }
            if (!isAllSame) break;
        }

        // case 1: all same → leaf node
        if (isAllSame) {
            return new Node(firstVal === 1, true, null, null, null, null);
        }

        // case 2: not uniform → divide into 4 parts
        let half = Math.floor(n / 2);
        let topLeftNode = dfs(half, r, c);
        let topRightNode = dfs(half, r, c + half);
        let bottomLeftNode = dfs(half, r + half, c);
        let bottomRightNode = dfs(half, r + half, c + half);

        return new Node(true, false, topLeftNode, topRightNode, bottomLeftNode, bottomRightNode);
    };

    return dfs(grid.length, 0, 0);
};

⏱️ Complexity Analysis

Time Complexity

At each level, we scan an n x n block to check if it’s uniform.
Then we split into 4 subproblems of size n/2.

So recurrence:

T(n) = 4T(n/2) + O(n^2)

This looks like O(n^2 log n) in the worst case.
But since each cell is checked only once in practice, the overall complexity simplifies to O(n^2).

👉 This is optimal since we must inspect every cell at least once.

Space Complexity

The recursion depth is O(log n) (each time we halve n).
The QuadTree itself can take up to O(n^2) nodes in the worst case (checkerboard pattern).

So space complexity is O(n^2).

🎯 Key Takeaways

QuadTrees are great for representing 2D uniform data efficiently.
If a subgrid is uniform, we don’t need to store every cell → compression.
Divide & conquer makes this problem elegant and intuitive.

Leetcode - 148. Sort List

Rakesh Reddy Peddamallu — Mon, 01 Sep 2025 11:41:18 +0000

Sorting a linked list isn’t as straightforward as sorting an array. With arrays, we can do quick sort or heap sort thanks to random access. But linked lists only allow sequential access, making those methods inefficient.

That’s where merge sort shines. It works beautifully on linked lists because splitting and merging can be done in-place with pointers. Let’s dive in.

🔹 Problem Statement

Given the head of a linked list, return the list sorted in ascending order.

Example:

Input:  4 → 2 → 1 → 3
Output: 1 → 2 → 3 → 4

🔹 Approach: Divide and Conquer

We apply the merge sort strategy:

Divide: Use the slow–fast pointer trick to find the middle and split the list into two halves.
Conquer: Recursively sort both halves.
Combine: Merge the two sorted halves back together.

🔹 Step 1: Find the Middle

We use two pointers:

slow moves one step at a time.
fast moves two steps at a time.

When fast reaches the end, slow will be at the middle.

const getMid = (head) => {
    let slow = head;
    let fast = head.next; // ensures we stop at the "first middle" for even length

    while (fast && fast.next) {
        slow = slow.next;
        fast = fast.next.next;
    }

    return slow; // returns middle node
}

🔹 Step 2: Merge Two Sorted Lists

This step is similar to merging two sorted arrays:

const merge = (list1, list2) => {
    let dummy = new ListNode(0);
    let tail = dummy;

    while (list1 && list2) {
        if (list1.val < list2.val) {
            tail.next = list1;
            list1 = list1.next;
        } else {
            tail.next = list2;
            list2 = list2.next;
        }
        tail = tail.next;
    }

    // attach the remaining part
    tail.next = list1 || list2;
    return dummy.next;
}

🔹 Step 3: Recursive Merge Sort

var sortList = function (head) {
    if (!head || !head.next) return head; // base case

    // 1. Split into two halves
    let mid = getMid(head);
    let right = mid.next;
    mid.next = null; // break the link
    let left = head;

    // 2. Recursively sort both halves
    left = sortList(left);
    right = sortList(right);

    // 3. Merge the sorted halves
    return merge(left, right);
};

🔹 Walkthrough Example: `4 → 2 → 1 → 3`

Step 1: Initial Split

Mid = 2
Left = 4 → 2
Right = 1 → 3

Step 2: Sort Left (`4 → 2`)

Mid = 4
Left = 4
Right = 2
Merge → 2 → 4

Step 3: Sort Right (`1 → 3`)

Mid = 1
Left = 1
Right = 3
Merge → 1 → 3

Step 4: Merge the Halves

Merge 2 → 4 and 1 → 3:

Compare 2 vs 1 → pick 1
Compare 2 vs 3 → pick 2
Compare 4 vs 3 → pick 3
Leftover → 4

Result: 1 → 2 → 3 → 4 ✅

Recursion Tree

sort(4 2 1 3)
   /        \
sort(4 2)  sort(1 3)
  /   \      /   \
 4     2    1     3

Merges:
(4,2) → (2 4)
(1,3) → (1 3)
(2 4) + (1 3) → (1 2 3 4)

🔹 Complexity Analysis

Time Complexity:
- Splitting takes O(log n) levels.
- Each merge across levels costs O(n).
- Overall: O(n log n).
Space Complexity:
- Merge happens in-place with pointers → O(1) extra space.
- Recursion depth = O(log n).

🔹 Why Merge Sort Works Best for Linked Lists?

Quick sort needs random access (bad for linked lists).
Merge sort only needs sequential traversal (perfect fit).
Splitting and merging are pointer operations, so memory overhead is minimal.

✅ Final Takeaway

Use slow–fast pointers to find the middle.
Recursively sort both halves.
Merge with pointer juggling.
Achieve O(n log n) efficiency with minimal space overhead.

👉 Next time someone asks “How do you sort a linked list?”, you’ve got a clean, interview-ready answer. 🚀