10 Proven Strategies to Supercharge API Performance in Legacy Projects

In legacy projects, prolonged API response times often surface during cost‑reduction and efficiency initiatives; this article shares a universal set of optimization techniques to address those performance bottlenecks.

1. Batch Processing

Batch operations reduce repeated I/O by aggregating database writes after a bulk operation completes, allowing a single insert or update instead of many individual calls.

batchInsert();

2. Asynchronous Processing

For time‑consuming tasks that are not required for the immediate result, move the logic to asynchronous execution to lower API latency. For example, a financial purchase interface can defer accounting and file‑writing to background workers.

Implementation options include thread pools, message queues, or scheduled task frameworks.

3. Space‑for‑Time (Caching)

Cache frequently accessed, rarely changed data to avoid repeated database queries or calculations. Proper cache usage must consider consistency trade‑offs.

4. Preprocessing

Pre‑compute values (e.g., annualized returns from net asset values) and store them, so API calls can retrieve ready‑made results without runtime calculations.

5. Pooling

Reuse expensive resources such as database connections or threads via connection pools, reducing creation overhead and improving throughput.

6. Serial to Parallel

Convert independent sequential calls into parallel executions to cut total latency, provided there are no result dependencies.

7. Indexing

Appropriate indexes dramatically speed up data retrieval; the article notes common scenarios where indexes may not be effective.

8. Avoid Large Transactions

Long‑running transactions hold database connections, hurting concurrency. Solutions include keeping RPC calls out of transactions, performing reads outside transactions, and limiting data processed within a transaction.

@Transactional(value = "taskTransactionManager", propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, rollbackFor = {RuntimeException.class, Exception.class})
public BasicResult purchaseRequest(PurchaseRecord record) {
    BasicResult result = new BasicResult();
    ...
    pushRpc.doPush(record);
    result.setInfo(ResultInfoEnum.SUCCESS);
    return result;
}

9. Optimize Program Structure

Repeated iterations can lead to tangled code with redundant queries and object creations; refactoring the overall API flow and re‑ordering code blocks can eliminate these inefficiencies.

10. Deep Pagination

Using a continuously increasing primary‑key column for pagination (e.g., WHERE id > 100000 LIMIT 200) leverages index scans and avoids the performance penalty of large offsets.

select * from purchase_record where productCode = 'PA9044' and status=4 and id > 100000 limit 200

11. SQL Optimization

SQL tuning—combined with proper indexing, pagination, and query design—significantly boosts API query performance.

12. Lock Granularity

Coarse‑grained locks degrade performance; lock only the minimal critical section, analogous to locking just a bathroom door instead of the entire house.

// Non‑shared resource
private void notShare() {}
// Shared resource
private void share() {}
private int right() {
    notShare();
    synchronized (this) {
        share();
    }
}

In summary, API performance issues usually accumulate over multiple development cycles; adopting higher‑level design thinking and the above techniques can dramatically improve efficiency and reduce costs.