About me

Analyze this Spring Boot project and its CI pipeline to determine why:

- The build takes approximately 15 minutes

- Test execution takes approximately 30 to 40 minutes

- The complete pipeline takes approximately 45 to 55 minutes or longer

Generate a standalone HTML report at:

reports/springboot-pipeline-performance-report.html

Do not modify production code, test code, pipeline configuration, generated files, or dependency versions. You may create only the HTML report and temporary analysis files.

Follow all repository instructions, including AGENTS.md.

Primary objectives

1. Reconstruct the complete CI pipeline timeline.

2. Separate dependency resolution, compilation, packaging and test execution.

3. Identify the slowest test classes, methods and Spring contexts.

4. Detect duplicated or unnecessary pipeline work.

5. Find safe opportunities for caching and parallel execution.

6. Estimate realistic improvements and the resulting pipeline duration.

7. Produce an actionable, evidence-based HTML report.

Important constraints

- Do not assume Kubernetes is responsible for the delay.

- Focus primarily on build and test performance.

- Do not invent measurements.

- Clearly distinguish measured findings from hypotheses.

- Do not expose credentials or sensitive configuration.

- Do not publish Gradle Build Scans or upload repository information.

- Do not connect tests to production or shared environments.

- Do not repeatedly execute the complete test suite.

- Prefer existing CI logs and test reports before running expensive commands.

- If a complete baseline test run is safe, execute it at most once.

- Ask for approval before running anything that could access external services or take more than one hour.

Phase 1: Discover the build and CI system

Inspect:

- pom.xml and all module-level pom.xml files

- Maven wrapper and .mvn configuration

- build.gradle, build.gradle.kts and settings files

- Gradle wrapper and gradle.properties

- Jenkinsfile and Jenkins shared-library references

- .github/workflows

- .gitlab-ci.yml

- azure-pipelines.yml

- cloud-build configuration

- shell scripts used by the pipeline

- Dockerfile and container-build configuration

- Surefire, Failsafe, JaCoCo and Sonar configuration

- JUnit Platform configuration

- Testcontainers configuration

- Existing Surefire, Failsafe, JUnit XML and Gradle test reports

Determine the exact commands executed by CI.

Check whether CI accidentally executes tests multiple times through patterns such as:

- mvn test followed by mvn package

- mvn package followed by mvn verify

- mvn install followed by another test command

- unit tests included in both Surefire and Failsafe

- the same test task executed in multiple pipeline stages

- tests executed during both JAR creation and container-image creation

- repeated clean builds

- repeated compilation across pipeline jobs

- Maven reactor modules being rebuilt unnecessarily

Phase 2: Reconstruct the pipeline timeline

Create a timeline for:

1. Agent or runner startup

2. Repository checkout

3. Dependency resolution

4. Code generation

5. Main-source compilation

6. Test-source compilation

7. Unit tests

8. Integration tests

9. Spring Boot packaging

10. JaCoCo report and coverage verification

11. Static analysis

12. Sonar analysis

13. Container-image build

14. Artifact publication

15. Any deployment steps

For every stage report:

- Measured duration

- Evidence source

- Whether the stage is CPU, memory, disk, network or external-service bound

- Whether work is repeated

- Whether caching is enabled

- Whether parallel execution is enabled

- Potential time saving

- Confidence level

If the pipeline does not expose stage durations, explain exactly how timing should be added.

Phase 3: Analyze the 15-minute build

Investigate:

- Dependency downloads on every pipeline run

- Missing Maven, Gradle or Docker caches

- Slow or unavailable artifact repositories

- Snapshot and dynamic dependencies

- Excessive Maven plugins

- Code-generation plugins

- Annotation processing

- OpenAPI, protobuf, JAXB or QueryDSL generation

- Frontend builds embedded in Maven or Gradle

- Repeated clean compilation

- Unnecessary modules being built

- Single-threaded multi-module builds

- Maven reactor structure

- Gradle build-cache configuration

- Gradle configuration-cache compatibility

- Docker cache invalidation

- Excessively large Docker build context

- Tests being executed during the reported build stage

- JaCoCo instrumentation or report generation

- Sonar analysis included in the build duration

- CI CPU, memory and disk constraints

For Maven projects, evaluate whether these are appropriate:

- Persistent local repository cache

- Maven dependency cache keyed by pom.xml files

- Maven parallel reactor builds using -T

- Building only affected modules with -pl and -am

- Separating package creation from test execution

- Avoiding unnecessary clean executions

For Gradle projects, evaluate:

- Dependency-cache persistence

- org.gradle.caching=true

- Configuration cache

- Parallel execution

- Worker count

- Gradle daemon behavior in CI

- Building only affected tasks and modules

Do not recommend flags without checking whether the project and plugins support them safely.

Phase 4: Analyze the 30 to 40-minute test stage

Parse existing test reports and produce:

- Total number of tests

- Passed, failed, skipped and retried tests

- Total test duration

- Slowest 20 test classes

- Slowest 30 test methods, when method-level timings are available

- Test duration distribution

- Unit versus integration-test duration

- Time spent in setup and teardown

- Tests with suspiciously round durations such as 5, 10, 30 or 60 seconds

- Tests with high duration variance

- Flaky tests or tests that are retried

- Tests that appear to hang until a timeout

Inspect test code for:

- @SpringBootTest

- @WebMvcTest and other test slices

- @DirtiesContext

- @Transactional

- @Sql

- Testcontainers

- Embedded Kafka, Redis, MongoDB or databases

- WireMock and MockWebServer

- Awaitility

- Thread.sleep

- Polling loops

- Fixed delays

- Long connection or request timeouts

- Calls to real external services

- Database cleanup before or after every test

- Schema creation for every test class

- Flyway or Liquibase migrations for every Spring context

- Container startup for every test class

- Dynamic ports or properties that prevent Spring context reuse

- Mock beans and test configurations that create unique contexts

- Excessive application-context creation

- Sequential tests that could safely run in parallel

- Shared mutable state that prevents parallelization

- Fork settings that restart the JVM too frequently

- Memory pressure, garbage collection or process swapping

- Expensive fixture generation

- Large files repeatedly loaded from disk

- Cryptographic key generation

- Docker image pulls during Testcontainers tests

Pay special attention to Spring test-context caching. Estimate how many distinct application contexts are being created and identify annotations or dynamic properties that prevent context reuse.

Phase 5: Safe measurements

First use existing CI logs and XML reports.

If a safe local baseline is possible, select commands appropriate to the discovered build system and measure separately:

- Dependency resolution

- Compilation without tests

- Unit tests

- Integration tests

- Packaging without rerunning tests

- Full verification

Do not run tests against production or shared infrastructure.

Record:

- Wall-clock duration

- CPU time when available

- Peak memory when available

- Test report duration

- Number of worker processes

- Number of test JVM forks

- Available CPU and memory

- Cache hits and misses

If local execution differs from CI, do not treat local results as CI measurements.

Phase 6: Recommendations

Group recommendations into:

1. Immediate quick wins

2. Build caching improvements

3. Test-code improvements

4. Spring context improvements

5. Test parallelization

6. CI infrastructure improvements

7. Longer-term test architecture changes

Consider recommendations such as:

- Persisting Maven or Gradle dependency caches

- Enabling build-output caching

- Removing duplicate build or test execution

- Separating unit and integration tests

- Parallelizing independent test groups

- Sharding tests across CI workers

- Reusing Spring application contexts

- Reusing Testcontainers safely

- Moving slow external-system tests to a separate pipeline

- Replacing fixed sleeps with condition-based waits

- Mocking unnecessary external calls

- Running affected-module tests on pull requests

- Keeping a complete test suite for merge or scheduled pipelines

- Right-sizing CI CPU and memory

Do not recommend skipping important tests merely to make the pipeline faster.

Evidence requirements

For every finding include:

- Finding

- Category

- File and line number

- Evidence

- Current estimated cost

- Root cause

- Recommended improvement

- Estimated time saved

- Confidence: High, Medium or Low

- Implementation complexity

- Risk

- Validation method

Use these evidence labels:

- Measured

- Confirmed from configuration

- Confirmed from code

- Strong hypothesis

- Weak hypothesis

- Unknown

Estimation rules

- Use ranges rather than false precision.

- Do not add overlapping savings together.

- State all assumptions.

- Separate build savings from test savings.

- Separate local measurements from CI measurements.

- Do not claim test parallelization savings without considering shared state and CI CPU availability.

- Do not assume doubling workers halves the duration.

- Include conservative, expected and optimistic scenarios.

HTML report requirements

Produce a polished, self-contained HTML file with embedded CSS and JavaScript. Do not use external CDNs.

Include:

1. Executive summary

2. Current estimated pipeline timeline

3. Build-stage analysis

4. Test-stage analysis

5. Slowest test classes and methods

6. Spring context analysis

7. Duplicate-work analysis

8. Caching analysis

9. Parallelization and test-sharding analysis

10. Prioritized recommendations

11. Estimated improvement scenarios

12. Proposed optimized pipeline

13. Validation plan

14. Missing evidence

15. Files inspected

16. Commands executed

Include this prioritization table:

Priority | Finding | Evidence | Current cost | Estimated saving | Confidence | Effort | Risk

Include visualizations for:

- Current pipeline waterfall

- Build versus test duration

- Slowest tests

- Test duration distribution

- Proposed pipeline waterfall

- Conservative, expected and optimistic outcomes

For the proposed pipeline, estimate whether the current 45 to 55-minute duration could realistically be reduced to:

- Under 40 minutes

- Under 30 minutes

- Under 20 minutes

Explain what changes are required for each target.

Final response

After generating the report, provide:

1. The report file path

2. The five largest confirmed or suspected bottlenecks

3. The slowest test classes

4. Whether tests are being executed more than once

5. Whether Spring contexts are being recreated excessively

6. The expected pipeline duration after safe quick wins

7. Missing CI logs or reports required for better estimates

Do not implement any optimization until I explicitly approve it.