HTTP Status Codes Simplified

Ever wondered why your API sometimes screams at you with random 3-digit numbers? Let me simplify this for you. HTTP Status Codes — the language your server speaks when it cannot talk to you directly. Every backend dev who skips learning these properly ends up googling them at 2 AM during production incidents. Do not be that person. Here is what those numbers actually mean: → 2xx — Everything went well Server received your request. Processed it. Sent back the goods. → 200 OK — classic success → 201 Created — you built something new on the server → 202 Accepted — request is in, but processing is still happening Know which one to return in your REST APIs. They are NOT interchangeable. → 3xx — You are being redirected The resource moved. Server is politely pointing you elsewhere. → 301 = gone forever, update your bookmarks → 302 = temporarily elsewhere, come back later → 304 = nothing changed, use your cached version This is where SEO and API versioning decisions live. → 4xx — You made a mistake Stop blaming the server. The problem is on the client side. → 400 = your request is malformed → 401 = prove who you are first → 403 = I know who you are, but you cannot enter → 404 = this thing does not exist → 405 = wrong HTTP method, read the docs → 408 = you took too long, connection dropped Most debugging time in backend dev lives right here. → 5xx — The server made a mistake Now it is not your code. It is the infrastructure sweating. → 500 = something broke on the server, no specifics → 501 = this feature is not built yet → 502 = bad response from an upstream server → 503 = server is overwhelmed or down → 504 = upstream server took too long to respond This is the category that triggers incident alerts and ruins weekends. 18 status codes. One cheat sheet. Zero excuses for not knowing these. Whether you are building REST APIs, debugging microservices, or just cracking Java backend interviews - these codes come up everywhere. Screenshot this. Pin it somewhere visible. You will need it sooner than you think #HTTPStatusCodes #BackendDevelopment #Java #SpringBoot #SystemDesign #SoftwareEngineering #DSA #WebDevelopment #JavaDeveloper #CodingTips

Most REST APIs aren't actually REST. They're just HTTP with JSON. After years of building Java-based REST services, I've seen this pattern more times than I can count — endpoints that call themselves "RESTful" but don't go beyond basic HTTP calls. That's where the Richardson Maturity Model (RMM) becomes a real eye-opener. Leonard Richardson broke REST maturity into 4 levels: 🔹 Level 0 — The Swamp of POX One endpoint, one HTTP method (usually POST), everything tunneled through it. Think old-school SOAP services. No real REST here. 🔹 Level 1 — Resources You start modeling your domain as resources (/orders, /users). But you're still not leveraging HTTP properly. 🔹 Level 2 — HTTP Verbs Now you're using GET, POST, PUT, DELETE meaningfully. Status codes like 201, 404, 409 are used correctly. This is where most production Java APIs live — and where many teams stop. 🔹 Level 3 — HATEOAS Hypermedia as the Engine of Application State. Responses include links that tell the client what it can do next. The API becomes self-discoverable. In Spring, this is achievable with Spring HATEOAS out of the box. The honest truth from the field: Most enterprise systems sit comfortably at Level 2 — and that's often good enough. But understanding Level 3 makes you design better APIs even if you don't fully implement HATEOAS. It forces you to think: "What can the client do after this response?" That mindset shift alone has improved how I design resource relationships, pagination links, and error responses in every Java project I've worked on. Where does your API sit on the RMM? Drop a level below 👇 #Java #RestAPI #SpringBoot #SoftwareEngineering #APIDesign #BackendDevelopment #HATEOAS #WebServices #JavaDeveloper #CleanCode

Stop designing APIs like it's 2015. Most developers still make these 7 mistakes that silently kill performance, scalability, and developer experience. After 14 years of building distributed systems, here's what I've learned the hard way: 1. Returning entire objects when clients need 2 fields Use field filtering: GET /users?fields=name,email Your bandwidth bill will thank you. 2. No versioning strategy from Day 1 "We'll add it later" = breaking 50 clients at 2 AM. Start with /v1/ in your URL or use header-based versioning. 3. Using HTTP 200 for everything 200 with {"error": "not found"} is NOT okay. Use proper status codes: 201, 204, 400, 404, 429. 4. Ignoring pagination on list endpoints Returning 10,000 records in one response? Your database and your users are both crying. 5. Synchronous processing for long-running tasks Don't make clients wait 30 seconds. Return 202 Accepted + a polling URL or use WebSockets. 6. No rate limiting until the system crashes Rate limit from Day 1. Not after the incident postmortem. Use token bucket or sliding window algorithms. 7. Inconsistent naming conventions /getUsers, /fetch_orders, /retrieveProducts? Pick ONE style (camelCase or snake_case) and stick to it. Good API design is not about following REST rules perfectly. It's about making life easier for the developers consuming your API. Which of these mistakes have you seen (or made)? Drop your biggest API horror story below. Follow Kuldeep Singh for daily System Design & Java insights. #SystemDesign #APIDesign #Java #Microservices #SoftwareArchitecture #BackendDevelopment #SpringBoot #TechLeadership #Programming #WebDevelopment

🚨 Stop guessing API errors. Read them like a pro. Ever spent 30 minutes debugging… just to realize it was a 400 Bad Request? 😅 👉 Understanding HTTP status codes is not optional. It’s a superpower for every backend & full stack developer. ⚡ API Status Codes — what they REALLY mean: 🟢 2xx = You’re good ✔️ 200 → Everything worked ✔️ 201 → Resource created ✔️ 204 → Success, no content 🔵 3xx = Look somewhere else ➡️ 301 → Permanent redirect ➡️ 302 → Temporary redirect ➡️ 304 → Use cache 🟡 4xx = You messed up (client side) ⚠️ 400 → Bad request (invalid input) 🔐 401 → Not authenticated ⛔ 403 → Not allowed 🔍 404 → Not found ⚡ 409 → Conflict 🧪 422 → Validation failed 🚦 429 → Too many requests 🔴 5xx = Server is crying 💥 500 → Internal error 🌐 502 → Bad gateway 📉 503 → Service unavailable ⏳ 504 → Timeout 🧠 Debug faster with this mindset: ✔️ 2xx → Relax, it’s working ✔️ 3xx → Check URL / caching ✔️ 4xx → Fix your request ✔️ 5xx → Check logs + backend 🔥 Real talk: If you’re building APIs with Spring Boot, Node, or microservices, mastering this = faster debugging + better systems + less stress 💬 Be honest… Which status code wastes most of your time? 😅 #API #Backend #Java #FullStack #WebDevelopment #Debugging #SoftwareEngineering #Microservices #DevTips

What is an API? What is REST? What is RESTful API? Have a go at a beginners overview I wrote.

APIs started making sense to me when I stopped memorizing… and started understanding the flow 👇 At a basic level, an API is just a way for systems to communicate. But what actually happens when you hit an API? Let’s break it down: 1️⃣ Client sends a request Example: GET /users/1 2️⃣ Request reaches the server → Routed to the correct controller 3️⃣ Business logic runs → Service layer processes the request 4️⃣ Database interaction → Fetch / update data 5️⃣ Response is returned → Usually JSON So the real flow is: 👉 Client → Controller → Service → Database → Response What helped me most was understanding this: • APIs are not just endpoints • They are structured layers working together Also, things started clicking when I focused on: • HTTP methods (GET, POST, PUT, DELETE) • Status codes (200, 404, 500) • Request & response structure Still learning, but understanding this flow made backend development much clearer. If you're learning APIs, focus on the flow — not just the syntax. #BackendDevelopment #APIs #Java #SpringBoot #WebDevelopment #Developers #LearningInPublic

🚀 Understanding HTTP Status Codes in REST APIs While building APIs, one important thing is not just sending data… 👉 It’s also about sending the right response status. These are called HTTP Status Codes. They help the client understand what happened with the request. 🔹 Common Status Codes ✔ 200 – OK Request was successful Example: Data fetched successfully ✔ 201 – Created New resource created Example: User registered successfully ✔ 400 – Bad Request Invalid input from client Example: Missing or wrong data ✔ 404 – Not Found Requested resource not found Example: User ID does not exist ✔ 500 – Internal Server Error Something went wrong on the server 🔹 Example in Spring Boot @GetMapping("/users/{id}") public ResponseEntity<User> getUser(@PathVariable Long id) { User user = userService.findById(id); return ResponseEntity.ok(user); } If user is not found, we can return: return ResponseEntity.status(HttpStatus.NOT_FOUND).build(); 💡 Why Status Codes are important ✔ Help frontend understand response ✔ Improve API communication ✔ Make APIs more professional ✔ Very common in interviews Understanding status codes helped me connect concepts like exception handling, validation, and API design. #Java #SpringBoot #BackendDevelopment #APIDesign #Learning

🧩 Killing the "God Function": My First Big Refactor in Go 🛠️ Exams kept me away from the keyboard yesterday, but we are back! 📚🚀 Up until now, my signupHandler was doing everything. It was a massive "God Function" that read the HTTP request, decoded the JSON, validated the email and password, hashed the password, and talked to the database. It worked, but it was messy. Today, I started breaking it down, and my mentor guided me through a serious paradigm shift in how Go handles logic. Here are the 3 big lessons I learned while refactoring my validation logic into its own function: 1️⃣ Separation of Concerns ⚖️ I had to ask myself: What belongs in an HTTP handler, and what doesn't? JSON decoding stays in the handler because it's an HTTP concern. But checking if an email is valid? That is pure business logic. So, I ripped the validation out into its own function. 2️⃣ Idiomatic Naming & Signatures ✍🏾 In JavaScript, I might have written const signup_validation = (user) => {}. In Go, we use action verbs and camelCase. And because I only need to read the user data (not modify it), I pass it by value, not by pointer. The result: func validateSignup(u User) error 3️⃣ "True" is Redundant (The nil epiphany) 🤯 This was the hardest part for my brain to process. I wanted my function to return true or an error. But in Go, you don't need a boolean for success. You just return an error. If something fails, you return the error (e.g., errors.New("email required")). If it succeeds? You just return nil. In Go, nil is success. // The extracted, pure Go validation function func validateSignup(u User) error { if u.Email == "" { return errors.New("email is required") // No HTTP context here! } // ... password checks ... return nil // Success! } My API is finally starting to look like mature software, not just a beginner's script. We move! 💪🏾 To my fellow backend engineers: Do you extract your validation logic into completely separate packages, or keep them close to your HTTP handlers? Let’s gist in the comments 👇🏾 #Golang #BackendEngineering #SoftwareArchitecture #Refactoring #TechBro #TechInNigeria #WeMove

🚀 Day 44 – SpringBoot Validations This is one of those topics that looks simple… but directly impacts API quality, security, and production stability. What most beginners do (Manual Validation) 🔸 Write if-else checks in controller 🔸 Mix validation with business logic 🔸 Duplicate code everywhere 🔸 Poor error handling What professionals do (Spring Boot Validation) 🔸 Use annotations like @NotBlank, @Email 🔸 Add @Valid in controller → auto validation 🔸 Validation separate from business logic 🔸 Handle errors globally using @RestControllerAdvice Most Important Annotations (Must Know) 🔹 @NotNull → cannot be null 🔹 @NotEmpty → not null + not empty 🔹 @NotBlank → no null, empty, spaces 🔹 @Size → length control 🔹 @Email → valid format check 🔹 @Pattern → custom regex validation 🔹 @Min / @Max → numeric limits 🔹 @Positive → value > 0 ⚠️ Common Mistake (Interview Favorite) Difference most people get wrong: 🔸 @NotNull → allows "" and " " 🔸 @NotEmpty → blocks "" but allows " " 🔸 @NotBlank → blocks everything invalid ✅ Always use @NotBlank for Strings I’ve created a complete visual + hands-on document covering: ✔ Manual vs Annotation-based validation ✔ Step-by-step User API validation ✔ Valid & Invalid request cases ✔ Global Exception Handling ✔ All annotations with examples 📄 Worth going through once if you're serious about backend Repost 🔁 if this helps someone learning Spring Boot Follow Surya Mahesh Kolisetty for more backend deep dives #SpringBoot #Java #BackendDevelopment #API #Validation #Hibernate #SoftwareEngineering #Coding #InterviewPreparation #Developers #LearnInPublic #CFBR #Development #SystemDesign #CodingPractices

Building a Spring Boot REST API is easy. Building one that's maintainable, predictable, and production-ready, that takes deliberate practice. After working on APIs across fintech and enterprise systems, here are the practices I always come back to: Use HTTP semantics correctly GET for reads, POST for creation, PUT/PATCH for updates, DELETE for removal. Return the right status codes, 201 on creation, 204 on delete, 404 when a resource doesn't exist. Don't return 200 for everything. Centralize exception handling with @ControllerAdvice Never let raw stack traces leak to the client. Use @RestControllerAdvice with @ExceptionHandler to return consistent, structured error responses ,with a timestamp, status, message, and path every time. Validate input at the boundary Use @Valid + Bean Validation annotations (@NotNull, @Size, @Pattern) on your DTOs. Never trust what comes in over the wire. Fail fast at the controller layer, don't let bad data leak into your service or persistence layer. Version your API from day one /api/v1/orders is not premature, it's professional. URI versioning is the most explicit and easiest to route. Adding it after consumers are already integrated is painful. Don't learn that lesson the hard way. Paginate every collection endpoint Returning unbounded lists is a production incident waiting to happen. Spring Data's Pageable makes it trivial, use it by default, not as an afterthought when the table hits a million rows. Document with Springdoc OpenAPI Your API contract is part of your product. Auto-generate Swagger UI with Springdoc, annotate meaningfully so consumers don't have to guess what fields are required or what errors to expect. None of these are exotic. But skipping even one of them consistently leads to APIs that are brittle, hard to consume, and expensive to evolve. The best REST APIs feel obvious to the developer consuming them. That doesn't happen by accident, it's the result of small, deliberate decisions made at every layer. #Java #SpringBoot #RestAPI #BackendDevelopment #SoftwareEngineering #FullStackDevelopment #APIDesign #WebDevelopment #TechLeadership