Performance Optimization Skill

Purpose

This skill provides performance optimization guidance for the CIA platform across JVM tuning, PostgreSQL query optimization, Vaadin UI rendering, and Spring Framework efficiency. It ensures the political intelligence platform delivers responsive analysis to users.

When to Use This Skill

Apply this skill when:

• ✅ Diagnosing slow page loads or API response times

• ✅ Optimizing database queries for large political datasets

• ✅ Tuning JVM parameters for production deployment

• ✅ Improving Vaadin UI component rendering performance

• ✅ Reducing memory consumption in data processing pipelines

• ✅ Optimizing materialized view refresh schedules

• ✅ Profiling Spring application startup time

Do NOT use for:

• ❌ Security hardening (use security-by-design skill)

• ❌ Feature development without performance concerns

• ❌ UI styling changes that don't affect rendering

Performance Targets

Metric Target Measurement

Page load time < 3 seconds Lighthouse, browser DevTools

API response time < 500ms (p95) CloudWatch metrics

Database query time < 100ms (p95) PostgreSQL pg_stat_statements

JVM heap usage < 80% of max JMX / CloudWatch

Vaadin push latency < 200ms Client-side measurement

Startup time < 30 seconds Application logs

JVM Optimization

Recommended JVM Settings

Production JVM flags for CIA platform (Java 21+)

JAVA_OPTS="-server
-Xms2g -Xmx4g
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:+UseStringDeduplication
-XX:+OptimizeStringConcat
-XX:MetaspaceSize=256m
-XX:MaxMetaspaceSize=512m
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/cia/heapdump.hprof
-Djava.security.egd=file:/dev/./urandom"

Memory Optimization Patterns

// ✅ EFFICIENT: Stream processing for large datasets @Service public class VotingDataProcessor {

@Transactional(readOnly = true)
public void processVotingRecords(String sessionId) {
    try (Stream<VoteData> votes = voteRepository.streamBySession(sessionId)) {
        votes.map(this::analyzeVote)
             .filter(Objects::nonNull)
             .forEach(resultRepository::save);
    }
    // Stream auto-closes, no memory accumulation
}

}

// ❌ INEFFICIENT: Loading all records into memory public void processVotingRecords(String sessionId) { List<VoteData> allVotes = voteRepository.findBySession(sessionId); // May load millions of records into heap }

PostgreSQL Query Optimization

Index Strategy for Political Data

-- High-impact indexes for common CIA queries -- Politician lookup by party and status CREATE INDEX idx_person_party_status ON person_data (party, status) WHERE status = 'ACTIVE';

-- Voting record time-series queries CREATE INDEX idx_vote_date_committee ON vote_data (vote_date DESC, committee_id);

-- Document search optimization CREATE INDEX idx_document_search ON document_content USING gin(to_tsvector('swedish', content));

-- Materialized view refresh tracking CREATE INDEX idx_mv_refresh_status ON materialized_view_log (view_name, last_refresh DESC);

Query Anti-Patterns

// ❌ N+1 Query Problem @Entity public class Committee { @OneToMany(fetch = FetchType.LAZY) private List<CommitteeMember> members; } // Accessing committee.getMembers() in a loop = N+1 queries

// ✅ FIX: Use JOIN FETCH or EntityGraph @Query("SELECT c FROM Committee c JOIN FETCH c.members WHERE c.id = :id") Committee findWithMembers(@Param("id") Long id);

// ✅ FIX: Use @EntityGraph @EntityGraph(attributePaths = {"members", "members.person"}) Committee findById(Long id);

Materialized View Optimization

-- Concurrent refresh to avoid locks during read REFRESH MATERIALIZED VIEW CONCURRENTLY view_riksdagen_politician_summary;

-- Schedule refresh based on data freshness requirements -- High priority: refresh every 15 minutes during business hours -- Low priority: refresh daily during off-peak

Vaadin UI Performance

Lazy Loading for Large Datasets

// ✅ EFFICIENT: Lazy loading with DataProvider Grid<PoliticianSummary> grid = new Grid<>(PoliticianSummary.class); grid.setDataProvider( DataProvider.fromCallbacks( query -> politicianService.fetch(query.getOffset(), query.getLimit()), query -> politicianService.count() ) );

// ❌ INEFFICIENT: Loading all items upfront grid.setItems(politicianService.findAll()); // Loads everything

Component Optimization

// ✅ Use virtual scrolling for long lists grid.setPageSize(50); grid.setMultiSort(true);

// ✅ Minimize push updates @Push(transport = Transport.WEBSOCKET_XHR) public class MainView extends AppLayout { // Only push critical real-time updates }

// ✅ Defer non-critical UI updates UI.getCurrent().access(() -> { notificationComponent.update(newData); });

Bundle Size Reduction

• Use @CssImport instead of inline styles for reuse

• Enable production mode (vaadin.productionMode=true )

• Minimize custom JavaScript in @ClientCallable methods

• Use Vaadin's built-in components over custom widgets

Spring Framework Performance

Caching Strategy

@Service public class PoliticianService {

// Cache frequently accessed, rarely changing data
@Cacheable(value = "politicians", key = "#personId",
           unless = "#result == null")
public PoliticianSummary getPolitician(String personId) {
    return repository.findSummaryById(personId);
}

// Evict cache when data is updated
@CacheEvict(value = "politicians", key = "#personId")
public void updatePolitician(String personId, PoliticianUpdate update) {
    repository.update(personId, update);
}

}

Transaction Optimization

// ✅ Read-only transactions for queries (no dirty checking) @Transactional(readOnly = true) public List<VotingSummary> getVotingSummaries(String sessionId) { return votingRepository.findSummariesBySession(sessionId); }

// ✅ Batch operations for bulk inserts @Transactional public void importVotingData(List<VoteData> votes) { int batchSize = 50; for (int i = 0; i < votes.size(); i++) { entityManager.persist(votes.get(i)); if (i % batchSize == 0) { entityManager.flush(); entityManager.clear(); // Release memory } } }

Performance Testing

JMH Benchmarks for Critical Paths

@BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) @State(Scope.Benchmark) public class PoliticianLookupBenchmark {

@Benchmark
public void benchmarkPoliticianSearch() {
    politicianService.searchByName("test");
}

}

Monitoring Checklist

• ✅ Enable pg_stat_statements for query analysis

• ✅ Configure JMX export for JVM metrics

• ✅ Set up CloudWatch dashboards for response times

• ✅ Monitor Vaadin session count and memory usage

• ✅ Track materialized view refresh durations

• ✅ Alert on p95 latency threshold breaches

References

• PostgreSQL Performance Tips

• Vaadin Performance Best Practices

• Spring Boot Performance

• JVM Tuning Guide (Oracle)