# ThinkGeo Outperforms ArcGIS in Dynamic Vector-Tile Styling

Logan Hughes · August 14, 2026

> ThinkGeo Outperforms ArcGIS in Dynamic Vector-Tile Styling. A 2025 benchmark by the GIS Performance Lab clocked ThinkGeo's on-the-fly...

| Takeaway | Detail |
| --- | --- |
| Client-side vector-tile re-rendering beats server-side caching for dynamic style changes. | ThinkGeo's on-the-fly pipeline hit 38ms median pan latency vs. ArcGIS's 92ms when styles changed mid-session. |
| WebGL-based rendering enables smooth interactions and dynamic styling without round-trips. | MapLibre and other modern renderers leverage WebGL for crisp text and animations at any zoom level. |
| Vector tiles store geometry on the server but symbology and rendering run client-side. | This architecture shifts styling overhead to the client, eliminating server-side cache invalidation delays. |
| Benchmarking vector-tile performance requires measuring interaction latency, not just tile load times. | The 2025 GIS Performance Lab benchmark measured pan latency, revealing a 54ms advantage for dynamic styling. |

A 2025 benchmark by the GIS Performance Lab clocked ThinkGeo's on-the-fly vector-tile pipeline at 38ms median pan latency, while ArcGIS's cached tiles took 92ms for the same operation—but only when styles changed mid-session. That 54ms gap flips the conventional wisdom that server-side caching is always faster. For vector tiles, client-side re-rendering eliminates round-trips for style changes, making dynamic styling not just feasible but faster than pre-rendered alternatives.

The key is that vector tiles store only geometry on the server; symbology, rendering, and zoom-level definitions run on the client. This architecture, supported by WebGL-based renderers like MapLibre and OpenLayers, allows instant style updates without waiting for a server to regenerate tiles. The Mapbox Style Specification further enables flexible visual design, while modern WebGL engines handle smooth animations and crisp text at any zoom level.

Even with the added complexity of client-side rendering, the performance payoff is clear. The benchmark's 38ms result—achieved without any server-side cache—demonstrates that for interactive styling, the round-trip cost of cache invalidation outweighs the benefits of pre-rendering. As vector-tile adoption grows, developers should measure interaction latency, not just tile load times, to truly assess performance.

![ThinkGeo Outperforms ArcGIS in Dynamic Vector-Tile](https://static.mm-ais.com/article-images-ai/thinkgeo-outperforms-arcgis-in-dynamic-v-ai-6a6eb2d2.jpg)

## The 12ms vs 30ms Trap

The raw numbers—12ms for ThinkGeo's on-demand generation versus 30ms for ArcGIS's cache hit—look like a modest gap until you trace the full request lifecycle. The trap is assuming that a cache hit is the end of the story. It isn't. The moment your style JSON changes, ArcGIS's architecture punishes you with an additional round-trip that ThinkGeo never pays.

ArcGIS Vector Tile Service pre-generates .pbf tiles using ArcGIS Pro's 'Create Vector Tile Package' tool, storing them in a static cache served via CDN with a median cache-hit latency of 30ms (Esri, 2025). That number is clean and fast—for a static basemap. But the ArcGIS JavaScript API 4.x renderer, despite its WebGL acceleration, requires a full tile re-fetch whenever the style JSON changes. Every style tweak—a choropleth reclassification, a data-driven fill color, a visibility toggle—triggers a fresh network request for tiles that were already sitting in the client's memory. The cache hit was one round-trip; the style change adds another. You're now at 60ms of network latency before the WebGL pipeline even starts.

ThinkGeo's Web API, by contrast, generates vector tiles on-demand using a .NET Core pipeline, with a benchmark on an Azure D4v5 VM showing a median generation time of 12ms per tile (ThinkGeo, 2025). The key architectural difference isn't the generation speed—it's where that generation happens. ThinkGeo's API can be deployed as a serverless function (e.g., AWS Lambda) to reduce network distance; warm-start RTT is <5ms (AWS Lambda performance report, 2025). Co-locating the tile generator with your data source eliminates the tile server round-trip entirely for dynamic data. The style change that costs ArcGIS an extra 30ms round-trip costs ThinkGeo nothing, because ThinkGeo UI for Web supports style hot-swapping without re-fetching (ThinkGeo documentation).

From a computer vision perspective, this is the same trade-off between pre-rendered image caching and on-the-fly generation in generative models. A cached image is fast to serve but frozen; a generated image costs compute but adapts. The round-trip cost dominates latency in both cases. In vision pipelines, we've learned that batch inference co-located with the data source beats a distant cache for any workload requiring iteration. The same logic applies here: the number of round-trips, not the raw processing time, is the binding constraint.

| Workload | ArcGIS (pre-cached) | ThinkGeo (on-the-fly) | Winner |
| --- | --- | --- | --- |
| Static basemap, no style changes | 30ms cache hit (Esri, 2025) | 12ms generation + RTT | ArcGIS by ~2ms |
| Dynamic styling, style JSON changes | 30ms cache hit + 30ms re-fetch = 60ms | 12ms generation, no re-fetch | ThinkGeo by ~48ms |
| Real-time data updates | Cache invalidation + re-fetch | Co-located generation,

Canonical: https://colossis.io/blog/thinkgeo-outperforms-arcgis-in-dynamic-vector-tile-styling.php
Markdown: https://colossis.io/blog/thinkgeo-outperforms-arcgis-in-dynamic-vector-tile-styling.php/index.md