Performance is critical for developers building modern, data-intensive applications. This post looks at performance benchmarks of our Flutter Client SDK, focusing on two key metrics: initial sync time and incremental sync latency.
These benchmarks are designed to help developers assess PowerSync’s client-side performance across different types of devices and client environments.
Where Performance Matters in Sync
When implementing a sync engine with a client-server architecture, two important performance metrics stand out:
- Initial Sync Time: How quickly can a user start interacting with their data after logging in?
- Incremental Sync Latency: How quickly are changes propagated to devices via the server?
We benchmarked the PowerSync Flutter SDK on these dimensions to provide transparency into its performance across desktop, mobile, and web environments.
Benchmark Setup: Testing for Real-World Relevance
Our tests aim to isolate client-side performance while minimizing server-side variability. Here’s how we set up the benchmarks:
- Client ↔ Server Latency and Server-Side Overhead: Minimized by running the server stack locally.
- Data Volume: Benchmarked with datasets ranging from 10,000 to 10 million rows.
- Devices Tested:
- Linux Desktop (Ryzen 9 7900X, ext4 filesystem)
- Android (Pixel 8a, Android 14)
- Web (Flutter web with IndexedDB and OPFS storage)
The metrics represent the mean of 10 test runs.
Key Metrics
1. Initial Sync Time
Initial sync time measures the duration from when the sync connection opens to when all data is available locally. This is crucial for ensuring fast app load times, especially for users syncing large datasets.
- Desktop: Up to 27.6k rows/sec
- Mobile: Slower throughput, averaging 7.1k rows/sec on Android for 10k rows synced.
- Web: Performance varies significantly based on storage backends, with OPFS outperforming IndexedDB.
2. Incremental Sync Latency
Incremental sync latency tracks the round-trip time for updates to propagate through the system:
- Client creates a new record in its local database.
- Record is uploaded to the server, persisted in the backend database (Postgres in the case of these benchmarks) and the change is processed by PowerSync.
- Record is streamed back to the client. We include a default value for one of the columns populated by Postgres, which allows the client to detect that the roundtrip has completed and measure the latency.
We tested 1 update, 100 updates and 1,000 updates. For the 100 and 1,000 cases, the updates are uploaded as a single batch API call and persisted to Postgres using a single transaction.
The benchmarks showed that incremental syncing is quite fast. On Android, syncing 100 updates takes ~200ms for the full round-trip. On desktop, it’s even faster, clocking in at ~40ms.
Summarized Benchmark Results
For the complete dataset, see the table at the end of this post.
Insights from the Benchmarks
Initial Sync
- Throughput changes relative to dataset volume: Throughput is highest on native desktop environments but decreases with larger datasets and on web/mobile platforms.
- OPFS vs. IndexedDB: Flutter-Web using OPFS delivers faster performance compared to IndexedDB, especially with datasets over 100k rows.
Incremental Sync
- Consistent latency: Even with 1M+ rows, incremental sync latency remains consistent, demonstrating efficiency in managing large datasets.
- Web challenges: Concurrency limitations in Flutter-Web affect responsiveness during incremental updates.
Conclusion
PowerSync is engineered to handle demanding sync scenarios efficiently, across platforms. Benchmarks demonstrate that PowerSync delivers consistent performance, even with high client-side data volumes.
