Child dependency performance

Issue summary

A child dependency is performing inefficiently, causing delays in resolving multiple parent components that rely on it. This creates bottlenecks in component initialization and slows down overall app performance.

Platform target and tolerance:

• Target: 5 ms per call
• Tolerance: up to 20 ms per call

Why it matters

Because many components depend on this slow child dependency, its poor performance cascades throughout the app, resulting in widespread slowdowns and degraded user experience. Identifying and fixing these issues can be challenging without proper diagnostics, leading to longer development and maintenance cycles.

How severity is calculated

Severity	Definition
No issue raised	Resolution time ≤ 5 ms per call. No significant issue.
Low–Medium	Resolution time exceeds target but within tolerance (5–20 ms). Moderate impact.
High–Critical	Resolution time exceeds tolerance (> 20 ms). Indicates a severe performance bottleneck.

How to fix a child dependency performance issue

Since the Kotzilla platform has identified slow child dependencies during component initialization and runtime, your focus should now be on analyzing these specific components—especially their initialization code and runtime execution—and understanding how their performance affects the broader dependency graph.

Focus on:

• Prioritizing optimization efforts on the flagged slow dependencies
• Reducing the impact of these dependencies on parent components
• Simplifying and decoupling complex dependency chains to improve overall performance

Recommended actions

1. Prioritize optimization of critical dependencies
   Focus on optimizing the slow dependencies first. This can include caching frequent results, optimizing algorithms, or moving resource-intensive work off the main thread. Adjust Koin configurations where possible—for instance, switch from factory to single for dependencies that don’t need repeated instantiation, reducing overhead.

2. Reduce dependency complexity
   If a child dependency is particularly heavy, consider refactoring it by breaking complex logic into smaller parts or decoupling components through interfaces and abstractions. Simplifying dependencies improves maintainability and performance resilience.

3. Implement efficient resource management
   Ensure that dependencies performing heavy computations or resource access (e.g., database or network operations) use lazy initialization, efficient caching, and asynchronous processing to minimize blocking and reduce execution time.

Use the Kotzilla SDK API and Console to investigate

The Kotzilla Console provides detailed visibility into child dependency performance, helping you pinpoint which specific dependencies cause slowdowns.

Use the Timeline view to analyze resolution times and dependency graphs for each user session. The SDK API enables custom instrumentation to trace and profile slow dependencies for deeper investigation.

For full setup and usage, refer to the Kotzilla SDK API documentation.

Need help?

Struggling to fix slow child dependencies? Our experts are ready to help you optimize your app’s dependency graph for better performance. Reach out anytime for best practices and pro tips!