Code

Classes, objects, the four pillars, abstract vs interface

class box, visibility markers, attribute and method syntax, interface, abstract class, enum, and the three perspectives

is-a, has-a, uses-a; association, aggregation, composition; UML symbols

The single most useful design decision to get right

How much classes depend on each other, how well a class's parts belong together, and why low coupling with high cohesion makes code easy to change and test

An interface is a contract. It lists method names and parameters, and implementing classes write the code. Newer Java also allows a few methods with a body.

When a class implements an interface, it promises to provide a concrete implementation (method body) for every method declared in that interface.

Inheritance means one class is a subtype of another: the child extends the parent and gets its fields and methods. The child can add new ones or override existing methods.

Encapsulation means keeping an object’s data (state) hidden from the outside and only allowing access through controlled methods.

A constructor is a block of code that runs when you create an object with new ClassName(...). It has the same name as the class and no return type.

static means “belongs to the class, not to each object.”

Overriding means a subclass (or a class that implements an interface) provides its own implementation of a method that already exists in the parent or interface.

Generics let you write classes and methods that work with a type you specify later, so the compiler can check types and you avoid casting.

Exceptions are Java’s way of signaling that something went wrong (invalid input, missing resource, unsupported operation, etc.). If not handled, they can stop the program.

Cloneable is a marker interface in Java (no methods). If a class implements Cloneable, it is allowed to use the default cloning behavior from Object.clone().

A class defined inside another class is a nested class.

Dependency injection means a class does not create its dependencies itself. Instead, they are passed in from outside (e.g. via constructor or setter).

A fluent API lets you call multiple methods in a row on the same object, usually by having each method return this (the same object).

An enum is a class with a fixed list of instances. You use it when a value can only be one of a few known options, like a direction, a status, or a size.

equals() decides when two objects are the same value. hashCode() helps HashMap and HashSet find them. Override both.

A lambda is a short way to write a function without giving it a name or wrapping it in a class.

Every collection in Java sits under one of these interfaces.

After an LLD design, the next question is almost always what happens if two users do this at the same time. This note covers the minimum Java tools to answer it.

Why String can never change, how the string pool works, when to use StringBuilder, and how to write your own immutable class with defensive copies.

Stack vs heap, why Java is always pass by value, boxing traps like the Integer cache, how garbage collection decides what to free, and how Java apps still leak memory.

Why null causes so many bugs, how to use Optional well (and where not to), failing fast with requireNonNull, empty collections, and the Null Object pattern.

Modern Java for LLD rounds. Records for value objects, sealed types for a closed set of cases, pattern matching, switch expressions, and when var helps or hurts.

A class should have one reason to change, which really means one group of people who would ask you to change it.

Add new behaviour by adding new code, not by editing code that already works. Usually one interface and one class per variant.

If code works with a base type, it must keep working with any subtype. No surprise exceptions, no stricter inputs, no weaker promises.

No caller should be forced to depend on methods it never uses. Split fat interfaces by the role each caller plays.

Business logic should not depend on details like SMS vendors or databases. Both depend on an interface that the business side owns.

Exactly one instance, reachable from everywhere

Creating objects without naming the concrete class

Creating whole families of related objects

Objects with many optional parts

Copy an existing object instead of building a new one

Make an incompatible interface fit

Add behaviour at runtime without subclassing

One simple door in front of a complex subsystem

Treat a tree and a single item the same way

A stand-in that controls access to the real object

Share common state across huge numbers of objects

Split a class that varies in two directions into two hierarchies joined by a reference, so 3 x 3 combinations need 6 classes instead of 9.

Swap an algorithm at runtime

Tell many objects when something changed

Turn a request into an object you can queue or undo

Behaviour changes when internal state changes

Fix the steps, let subclasses fill them in

Walk a collection without exposing its internals

Pass a request along a chain until one handler takes it

Save and restore an object's state

Objects stop calling each other directly and go through one coordinator, so n objects need n links instead of n x (n - 1).

Pull operations like GST, shipping and invoice export out of your item classes, so a new operation is a new class and the items never change.

Model rules like "cartTotal > 499 AND city == Bengaluru OR isPrime" as a tree of small expression objects, so changing an offer means changing data, not code.

Strategy, enums, the classic starter question

State pattern

Small and self contained, good warm up

Scheduling, priority queues

State, transactions

Composite plus lambdas, very clean

Concurrency, seat locking, optimistic vs pessimistic

Command pattern, larger domain

Criteria and rules

Game rules, larger state machine

Policies, charging, expiry

The classic first LLD problem, built in layers with controllers, services and repositories, and a Java simulation you can run.

Low level design notes for a simplified Zomato style food ordering app.

Design an app that tracks shared expenses in a group, splits them equally, by exact amount or by percent, and works out who should pay whom.

Build a least recently used cache in Java with O(1) get and put, a hand made linked list and hash map, a swappable eviction policy and a simple thread safe wrapper.

Design the classes of an in-app rate limiter with token bucket, fixed window and sliding window log behind one interface, plus per user and per API rules.

Design a small logging framework with levels, loggers, console, file and in-memory appenders, formatters, a singleton manager and an async appender.

Build a small in-memory message broker where publishers post to topics, every subscriber gets its own queue and thread, and a slow subscriber never holds up the rest.

Design a small booking system for meeting rooms, with a one line overlap check, a sorted calendar per room, a lock per room against double booking, and a pluggable way to pick the room.

Show stacked toast messages that close on their own after 5 seconds or on the close button, with one timer per toast kept in a ref.

Fetch a list from an API page by page and render numbered page controls with previous and next buttons.

Build a modal that opens from a button and closes on its Close button or a mousedown outside the box, using a reusable useClickOutside hook.

Cycle through images with previous and next buttons, wrap around at both ends, and auto-advance on a timer that pauses on hover.

Search products as the user types, wait 1 second before each request, cancel stale requests, and cache the last 10 queries in a ref.

Render a list of questions where clicking one shows its answer, with each item holding its own open or closed state.

Render tab buttons from data and show the content of the active tab, keeping the active index in state.

Keep React state in localStorage with a typed usePersistedState hook, including JSON parsing and safe fallbacks.

Write a useTimeout hook that restarts when the delay changes but not when the callback changes, using a ref for the latest callback.

Build a small spreadsheet grid with editable cells, add rows and columns, and keep the grid as a 2D array in state.

Move tasks between columns with the native HTML drag and drop events, tracking the dragged item in a ref.

Cycle green, yellow and red lights every 2 seconds with one setInterval and a modulo on the active index.

Render a 24 hour day view with hourly slots and place each event block by its start and end time, at 5rem per hour.

Render only the rows that are visible in a long list by computing the window from scroll position and row height.

Show numbered steps joined by lines, highlight every step up to the current one, and move between steps with Back and Continue buttons.

Add, complete and delete todos, and keep the list in localStorage so it survives a refresh.

A tabs component that tells its parent which tab is active through an onTabChange callback.

Pick or drop a file, upload it with axios, and show progress, success and error states in TypeScript.

Flip numbered cards on a 6 by 6 grid to find matching pairs, lock the board while two cards are open, and flip mismatches back after 3 seconds.

Animate a progress bar to a given percentage with a CSS transform, and expose the value to screen readers.

Render a recursive folder tree where folders expand and collapse, and files and folders can be added or deleted.

A Trello style board where you add lists and cards, archive a list, and drag a card onto another list, with board data kept in a Redux store.

Chat in rooms with a Socket.IO server that relays messages and a React client that keeps login, room and messages in Redux Toolkit.

Pick cinema seats on a generated layout with seat categories, booked seats and a running total, built in TypeScript.

Move checked items between two lists with buttons for selected items and for all items.

Load job posts from the Hacker News API six at a time with a Load more button, fetching details for each id.

A checkbox tree where checking a parent checks all children and a parent becomes checked once all its children are.

Type a sentence one character at a time with a blinking cursor, using a timer that cleans up after itself.

Turn typed text into chips on Enter, ignoring empty input, and remove a single chip with its X button.

Upload images as stories that expire after 15 seconds, view them in a modal, and release object URLs to avoid leaks.

A reusable star rating with hover preview, half stars, keyboard support and read-only mode.

A Reddit style comment tree with replies at any depth, delete, and relative timestamps, using recursive components.

An LLM is a capability, a GenAI app is software built around it. Call a model from Postman, read the response and token usage, then build a ticket summariser in Spring Boot with Spring AI, Node.js and Python.

A model call is not a conversation. Roles, system prompts, app memory, the context window, streaming and hallucination, with a support chatbot built in Spring AI, Node.js and Python.

An LLM writes text but cannot act. Tools give it hands. Tool definitions, the tool calling loop, information vs action tools, and a sandboxed website builder agent in Spring AI, Node.js and Python.

Why a reply that streams feels faster even when it is not. Generation vs delivery, time to first token, chunked HTTP, SSE vs WebSockets, Flux in Spring AI, saving history after the stream, and reading it in the browser.

How a computer can hold meaning as numbers. Vectors, dimensions, distance, dot product and cosine similarity, why hand made features fail, and how training turns context into embeddings.

Build a small Netflix style search. Embedding model vs chat model, why sending the whole catalogue to an LLM fails, precomputed vectors, top K by cosine, and similar movies, in Spring AI, Node.js and Python.

What breaks when the movie search grows from 30 to millions of vectors. Exact vs similarity lookup, brute force top K, the real cost in compute and memory, and why B-trees and k-d trees stop helping in high dimensions.

How vector databases search millions of vectors fast by not looking at most of them. Approximate search and recall@K, IVF clusters, HNSW graphs, quantization and PQ, metadata filters, and pgvector.

A support bot that answers from company policy documents. Chunking, embedding, a pgvector store, retrieval, prompt stuffing with citations, and the ways RAG fails in production.

Why basic RAG misses rules and exact product codes, and how to fix retrieval with structural chunking, top K, thresholds, metadata filters, BM25 hybrid search, RRF, reranking and context engineering.

Turn one sentence into a typed MeetingDetails object your code can trust. Schemas, strict mode, the checks a schema cannot do, retries with feedback, in Spring AI, Node.js and Python.

Why every AI app rewriting the same tools does not scale, and how MCP fixes it. Hosts, clients and servers, tools/list and tools/call, and a task server with an LLM client in Spring AI, Node.js and Python.

An MCP server offers more than tools. Resources give the app context, prompts give the user ready workflows. Who controls each, how list and read work, and a task server and client in three stacks.

How a model reads an image (patches, a vision encoder, an adapter), what image tokens cost, size limits, upload safety, and a vision chat with a browser page in Spring AI, Node.js and Python.

An eval runner for a support agent with RAG and tools: a trace, a golden dataset, four checks in code, a judge with strict scores and a pass threshold, in Spring AI, Node.js and Python.

Prompt injection, jailbreaks and why a system prompt is not a lock. Five rules for safe tools, layered guardrails, and a guarded support agent in Spring AI, Node.js and Python.