Forem: Bharath Kumar J N

Day 3 - Added Security, Authentication and Jwt Tokens in REST API Project

Bharath Kumar J N — Sat, 04 Apr 2026 14:28:18 +0000

I restarted my coding journey with a simple rule:

Improve 1% every day.

The features I worked on today include:

Pagination
Request Validation
Spring Security
JWT Authentication

Pagination in the Task API

Earlier, my API returned all tasks at once. That works when the data is small, but in real applications the database can contain thousands of records.

So I added pagination to the API.

Now tasks can be fetched page by page instead of loading everything in one response. This improves performance and makes the API much easier for the frontend to handle.

Request Validation

I also implemented request validation.

Before this, the API would accept requests even if important fields like the title or description were missing. Now the API validates the input and returns an error if required fields are not provided.

Spring Security Integration

Another major step today was adding Spring Security.

This allows the application to protect certain endpoints and control who can access them. Authentication-related routes remain public, while task-related endpoints now require authentication.

JWT Authentication

To handle authentication, I implemented JWT (JSON Web Token).

Instead of storing sessions on the server, the application now uses token-based authentication. When a user logs in, the server generates a token. The client then sends that token with every request to access protected endpoints.

What I Learned Today

Today helped me understand several important backend concepts:

Why pagination is important for performance
How validation helps maintain data integrity
How Spring Security protects API endpoints
How JWT enables stateless authentication

Day 2 - Updated the REST API Project using ResponseEntity

Bharath Kumar J N — Thu, 02 Apr 2026 23:18:13 +0000

Refactoring the Controller Response

While building the API, I made a small improvement to the controller response handling.

Initially, the controller returned the data directly. Later, I updated it to use ResponseEntity to have better control over the HTTP response.

Before

@GetMapping
public List<Task> getAllTasks() {
    return taskService.getAllTasks();
}

What happens here

Spring automatically returns 200 OK
Response body contains the list of tasks
No direct control over HTTP response structure

After

@GetMapping
public ResponseEntity<List<Task>> getAllTasks() {
    List<Task> tasks = taskService.getAllTasks();
    return ResponseEntity.ok(tasks);
}

What improved

The method now returns a complete HTTP response
The HTTP status code is explicitly defined
Easier to handle different scenarios like errors or empty responses

Why This Matters

Using ResponseEntity makes the API more flexible and REST-friendly.

For example, we can now easily return different responses:

return ResponseEntity.ok(tasks);          // 200 OK
return ResponseEntity.notFound().build(); // 404 Not Found
return ResponseEntity.noContent().build();// 204 No Content

This small change improves API clarity, maintainability, and error handling.

Day 1 - Restart Coding | Built a REST API Project using Spring Boot Fundamentals

Bharath Kumar J N — Thu, 02 Apr 2026 02:24:08 +0000

For months, my coding routine looked like this:

Learn → Lose consistency → Stop → Restart again.

So today I decided to restart properly — and document everything I build in public.

This is Day 1.

Progress

I built a simple REST API using Spring Boot to refresh my backend fundamentals.

Instead of jumping into complex projects, I wanted to rebuild the basics properly.

Concepts

@RestController
@RequestMapping
Dependency Injection
Basic service layer structure
MVC architecture

Lesson

Trying to learn too many things at once is the fastest way to burn out.

Mindset

Not Trying to become an expert - Just Improving 1% Everyday

Starting My Coding Journey - From Confusion to Consistency

Bharath Kumar J N — Wed, 01 Apr 2026 01:09:08 +0000

Beginning My Coding Journey

Before starting, a small introduction.

My name is Bharath, and I'm a final-year Computer Science student.

For a long time, my coding journey looked like this:

Start learning → Lose consistency → Stop → Restart again.

I would learn something, get motivated for a few days, then slowly fall out of the routine. Eventually I realized that the biggest problem wasn't ability — it was consistency.

So this time I'm doing something different.

I decided to learn in public and document my journey.

What I'm Focusing On

Data Structures & Algorithms
Backend development with Spring Boot
Full-stack development
Building real projects instead of just watching tutorials

What I Will Share Here

Daily or Weekly coding progress
DSA problems I solve and what I learn from them
Projects I'm building
Mistakes, struggles, and lessons along the way

Current Goal

Become job-ready as a developer by
Building strong projects
Improving problem-solving skills
Stay Consistent

Why I'm Doing This

Posting publicly helps create accountability.

When you share your progress openly, it's harder to quit.

Also, I hope this journey can help or motivate someone else who is trying to learn programming.

If you're also learning to code, feel free to follow along.

Let's grow together.

Thanks for reading 🙌