Boost API Performance: 12 Proven Backend Optimization Techniques

For legacy projects, prolonged interface response times are a common bottleneck; this guide shares a universal set of optimization techniques.

1. Batch Processing

Group database operations to reduce I/O by inserting or updating records in bulk after processing.

<code>// for-loop single insert
list.stream().forEach(msg -> {
    insert();
});
// batch insert
batchInsert();
</code>

2. Asynchronous Execution

Move non‑critical, time‑consuming logic to asynchronous tasks (e.g., thread pools, message queues, or scheduling frameworks) to lower request latency.

3. Space‑for‑Time (Caching)

Cache frequently accessed, rarely changed data to avoid repeated database queries or calculations.

4. Pre‑Processing

Pre‑compute and store results (e.g., annualized returns) so that API calls can retrieve ready‑made values instantly.

5. Pooling

Reuse expensive resources such as database connections or threads via connection pools and thread pools.

6. Serial‑to‑Parallel Conversion

Execute independent operations concurrently when there are no result dependencies, significantly cutting total response time.

7. Indexing

Apply appropriate indexes to accelerate data retrieval; be aware of scenarios where indexes may not be effective.

8. Avoid Large Transactions

Keep transactions short and avoid embedding RPC calls or heavy queries inside them.

<code>@Transactional(value="taskTransactionManager", propagation=Propagation.REQUIRED, isolation=Isolation.READ_COMMITTED, rollbackFor={RuntimeException.class, Exception.class})
public BasicResult purchaseRequest(PurchaseRecord record) {
    BasicResult result = new BasicResult();
    // insert tasks
    taskMapper.insert(...);
    // ...
    return result;
}
</code>

Do not place RPC calls within the transaction; move them outside.

9. Refactor Program Structure

After multiple iterations, refactor code to eliminate redundant queries and object creation, improving maintainability and performance.

10. Deep Pagination

Replace offset‑based pagination (e.g.,

LIMIT 100000,200

) with keyset pagination using a continuously increasing column to leverage primary‑key indexes.

<code>SELECT * FROM purchase_record WHERE productCode='PA9044' AND status=4 AND id>100000 LIMIT 200;
</code>

11. SQL Optimization

Combine indexing, pagination, and query rewriting to enhance query speed.

12. Lock Granularity

Use fine‑grained locks only around truly shared resources; avoid over‑locking unrelated code sections.

<code>// correct locking
private void right() {
    notShare();
    synchronized(this) {
        share();
    }
}
</code>

Conclusion

Interface performance issues often stem from incremental, ad‑hoc code changes; adopting these higher‑level design and optimization principles can dramatically improve efficiency and reduce costs.