Service-to-service communication in Spring Boot - Performance & Optimization

Performance: Service-to-service communication

MEDIUM IMPACT

This affects the speed and responsiveness of backend interactions that impact frontend load times and user experience.

Calling another microservice synchronously for data

Spring Boot

private final WebClient webClient = WebClient.create();
Mono<String> response = webClient.get().uri("http://service/api/data").retrieve().bodyToMono(String.class);

Uses non-blocking WebClient with connection pooling, freeing threads and improving scalability.

📈 Performance GainNon-blocking calls improve throughput and reduce latency under load

Calling another microservice synchronously for data

Spring Boot

RestTemplate restTemplate = new RestTemplate();
String response = restTemplate.getForObject("http://service/api/data", String.class);

Creates a new RestTemplate instance per call and blocks thread until response arrives, causing thread starvation under load.

📉 Performance CostBlocks thread, increasing response time and reducing throughput

Performance Comparison

Pattern	Thread Usage	Latency Impact	Network Cost	Verdict
Synchronous RestTemplate per call	Blocks thread	High latency	Medium	[X] Bad
Non-blocking WebClient with pooling	Non-blocking	Low latency	Medium	[OK] Good
Sequential service calls	Blocks threads sequentially	High cumulative latency	Medium	[X] Bad
Parallel reactive calls	Non-blocking	Low cumulative latency	Medium	[OK] Good
Large payloads	N/A	High latency	High	[X] Bad
Minimal DTOs with compression	N/A	Low latency	Low	[OK] Good

Rendering Pipeline

Service-to-service communication affects backend response times that influence frontend rendering speed and interaction readiness.

→Network

→Backend Processing

→Frontend Rendering

⚠️ BottleneckNetwork latency and blocking backend threads

Core Web Vital Affected

INP

This affects the speed and responsiveness of backend interactions that impact frontend load times and user experience.

Optimization Tips

1Use non-blocking HTTP clients like WebClient instead of blocking RestTemplate.

2Parallelize multiple service calls to reduce total wait time.

3Send only necessary data in payloads and use compression to reduce network cost.

Performance Quiz - 3 Questions

Which pattern improves backend responsiveness for service-to-service calls?

A Making synchronous calls sequentially

B Using non-blocking WebClient with connection pooling

C Creating a new RestTemplate instance per call

D Sending full large JSON payloads every time

DevTools: Network and Performance panels

How to check: Use Network panel to inspect request sizes and timings; use Performance panel to record backend response times and frontend interaction delays.

What to look for: Look for long backend response times, large payload sizes, and blocking main thread during interactions.