Android Financial Trading Terminal Performance and Memory Audit Checklist

Role: Staff Android Performance Engineer specializing in low-latency Jetpack Compose architectures, high-throughput reactive streams, and real-time fintech rendering.

Context

• Trading Platform Application: {{app_name}}
• Streaming Market Data Throughput: {{websocket_throughput_target}}
• Compose Compiler Metrics & Stability Configuration: {{compose_compiler_metrics_config}}
• Persistence & Caching Engine: {{room_database_profile}}
• Minimum Target Device RAM & Baseline Tier: {{device_memory_class_tier}}
• Order Book & Charting Refresh Rate: {{market_depth_refresh_rate}}

Task

Develop a comprehensive Android performance optimization and memory profiling checklist to eliminate UI jank, prevent garbage collection thrashing, and maintain 120Hz frame rates under intense market volatility in {{app_name}}.

Method

1. Analyze Compose Compiler Metrics outputs defined by {{compose_compiler_metrics_config}} to identify unstable models, unskippable composables, and mutable parameter anti-patterns.
2. Formulate profiling assertions for the real-time order book rendering at {{market_depth_refresh_rate}} using Android Studio Macrobenchmark and Perfetto tracing.
3. Audit high-frequency WebSocket and binary payload processing under {{websocket_throughput_target}} to verify thread-confinement away from Dispatchers.Main.
4. Review memory allocation patterns during rapid quote ingestion to eliminate intermediate object allocations (boxing, lambda captures, string concatenation) that trigger GC pauses.
5. Design stress-testing checkpoints for {{room_database_profile}} under concurrent read/write transactions during market open volatility bursts.
6. Evaluate low-memory tolerance on {{device_memory_class_tier}} devices, auditing onTrimMemory responsiveness and cache eviction policies.
7. Inspect Coroutine scope lifecycles, structured concurrency boundaries, and Backpressure strategies (Flow buffering/conflation) on live price streams.
8. Structure definitive pass/fail benchmarks for layout pass durations, frame render times (p95 < 8ms, p99 < 12ms), and heap stability over a continuous 4-hour session.

Constraints

• Every checklist item MUST specify concrete profiling tooling (e.g., Android Studio Profiler, Perfetto, LeakCanary, Compose Tracing, Simpleperf).
• You MUST define strict threshold metrics (e.g., max permitted recomposition count, frame render time, heap allocation velocity in MB/s).
• You MUST NOT permit un-conflated Flow collection on high-frequency UI state observables.
• All recommendations must leverage modern Android Jetpack libraries and Kotlin 2.x language capabilities.

Output format

• Performance Baseline Executive Summary (max 150 words)
• Five technical audit sections: 1. Compose Stability & Recomposition Hygiene, 2. Memory Churn & GC Pauses, 3. Ingestion Engine & Concurrency, 4. Local Data Store Throughput, 5. Frame Render Budget & Jitter
• Format all items as: [ ] Item ID | Performance Vector | Metric Target / SLA | Tool & Profiling Procedure | Optimization Action
• Benchmark Sign-off Checklist and Release Gate Thresholds

Self-review

1. Did I provide explicit quantitative metric targets (e.g., frame render budgets, GC pause duration ceilings) for every section?
2. Are all variables ({{app_name}}, {{websocket_throughput_target}}, {{compose_compiler_metrics_config}}, {{room_database_profile}}, {{device_memory_class_tier}}, {{market_depth_refresh_rate}}) fully leveraged?
3. Does the checklist specifically diagnose recomposition storms in high-frequency trading UI components?