🐌 “My Spring Boot API Became Slow… Until I Learned Pagination & Sorting”

Source: Dev.to

Why Sorting & Pagination Matter

In real applications:

• Databases grow fast
• Fetching everything at once is expensive
• Clients rarely need all data

Sorting and pagination help you:

• Improve performance
• Reduce memory usage
• Deliver faster APIs
• Build scalable systems

This is not optional in production backends.

Sorting Using Method Query Names

Spring Data JPA allows sorting directly in method names.

List findAllByOrderByNameAsc();
List findAllByOrderByNameDesc();

This works well when:

• Sorting logic is fixed
• Requirements are simple

But real applications need dynamic sorting.

Dynamic Sorting with the Sort Class

Sorting with repository methods

List findByDepartment(String department, Sort sort);

This allows clients to decide:

• Which field to sort
• Ascending or descending order

Creating Sort Objects

Sort sort = Sort.by(Sort.Direction.ASC, sortField);

Multiple sorting fields:

Sort sort = Sort.by(
    Sort.Order.asc("name"),
    Sort.Order.desc("salary")
);

Why Sorting Alone Is Not Enough

Even with sorting:

• Returning thousands of rows is inefficient
• APIs become slower
• Clients struggle to handle large responses

That’s where Pagination comes in.

Understanding Pagination

Key Pagination Concepts

Page

Represents a single chunk of data and also contains:

• Total elements
• Total pages
• Current page data

Pageable

Defines:

• Page number
• Page size
• Sorting rules

PageRequest

A concrete implementation of Pageable used to create pagination objects.

Using Pageable in Repositories

Spring Data JPA makes pagination extremely simple.

Page findAll(Pageable pageable);
Page findByLastName(String lastName, Pageable pageable);

No SQL. No complex logic. Just clean method signatures.

Creating a Pageable Instance

Pageable pageable = PageRequest.of(
    pageNumber,
    size,
    Sort.by("lastName").ascending()
);

With this you control:

• Page size
• Page number
• Sorting

All in one object.

The Mistake I Was Making

I used to:

• Fetch all records
• Sort in memory
• Ignore scalability

It worked… until data increased. After using pagination and sorting:

• APIs became faster
• Memory usage dropped
• Backend felt production‑ready

Final Thoughts

Sorting and pagination are not “extra features”. They are core backend fundamentals. If your Spring Boot APIs feel:

• Slow
• Heavy
• Hard to scale

Start here.

This post is part of my learning-in-public journey while exploring Spring Boot and real‑world backend development.