Repeated or missing results in a geo-search page sequence can come from changing index data, unstable sort order, mismatched continuation state, or an expired cached result set—not necessarily a single “cache bug.” To isolate the cause, compare the full normalized search request across pages, then check how the backend handles ordering, snapshots, and continuation.
How a page sequence becomes inconsistent
Offset pagination asks for a slice of an ordered result set: for example, skip the first 20 matches and return the next 20. If the index changes between those requests, the slice can shift. A new matching document inserted before the page boundary may push an item from page one into page two, producing a duplicate; related shifts can cause a result to be skipped.
As an Amazon Associate I earn from qualifying purchases.
OpenSearch documents this behavior for from/size: the parameters are stateless, so results use the latest available data. A page sequence assembled from separate requests is not automatically a snapshot of one fixed result set. OpenSearch: Paginate results
Recommended Free Tools
Geo filters do not remove the ordering problem
A bounding box or other spatial filter determines which documents match, but pagination still depends on the membership and order of those matches. If a location update, new document, filter change, or sort difference changes the set between requests, page boundaries may no longer line up.
#1 Best Overall
How a cache can contribute
A cache can return a response that does not correspond to the request or index state expected by the next page. For example, a cache key based only on a broad place name could omit exact geometry, filters, sort order, page size, or continuation token. Another possible mismatch is a cached first page followed by a newly generated second page from a changed index. These are failure modes to investigate, not an established diagnosis for any particular application.
Some geospatial paging systems use server-generated next or previous links and cache a result set for traversal. OGC Web Feature Service (WFS) 2.0 specifies an exception for an expired cached result set and requires servers to advertise cache timeout and whether paging is transactionally consistent. The exact behavior depends on the service and its implementation. OGC Web Feature Service 2.0 Interface Standard
What to compare across page requests
Record a request fingerprint for every page, then compare adjacent calls. Include the inputs that define both result membership and ordering, not just the displayed location name.
Free tools Windows power users keep installed
One-click scans. No signup required.
- Normalized geometry or bounding box, including the coordinate reference assumptions.
- All filters and query parameters that affect which features match.
- Sort fields and direction, including a unique, stable tie-breaker where the backend supports one.
- Page size and the offset, next link, cursor, or continuation token.
- Index or query version information, if available, and whether writes occurred between requests.
- Identifiers and order of the returned features, plus cache status and result-set expiry information where exposed.
Check that each cache key contains every request value that can change membership or order. Check that a next link or token remains associated with the original search rather than being reused with different filters or sort settings. Finally, establish whether the service promises a consistent snapshot across pages; do not infer snapshot consistency merely from receiving a continuation token.
Rank #3
Choose pagination for the depth and consistency you need
There is no universal pagination method: backend behavior, version, workload, and consistency requirements matter. Offsets can be convenient for shallow lists and direct access to a particular page, but deep offsets are costly or limited on several services. Continuation methods are better suited to walking a large result set, although their ordering and snapshot guarantees remain backend-specific.
| Method or service | Useful properties | Limits and considerations |
|---|---|---|
OpenSearch from/size |
Simple offset-based paging. | OpenSearch documents a 10,000-result limit for this method. Because requests are stateless and use the latest data, concurrent index changes can shift page boundaries. OpenSearch documentation |
| OpenSearch scroll | Keeps a search context for a period and returns batches that do not change with new data during that context. | Context duration and resource use must be managed; this is not a general promise for every backend or pagination API. OpenSearch documentation |
Elasticsearch search_after with a point in time |
Elasticsearch recommends this combination for deep pagination when the index view must be preserved. A unique sort tie-breaker helps avoid missing or duplicate hits. | Elasticsearch sets a default index.max_result_window of 10,000 hits for from/size. Its documentation says scroll is for processing large amounts of data, not real-time user requests. Elasticsearch: Paginate search results |
Amazon CloudSearch start/size and cursor |
A cursor is required to reach results beyond the first 10,000 hits. | CloudSearch warns stale cursors can return stale results; score-sorted cursor requests can be inconsistent across index updates or eventually consistent replicas. These are CloudSearch-specific cautions. Amazon CloudSearch: Paginating results |
| OGC WFS 2.0 paging | May provide server-generated next or previous links and cached result-set paging. | The standard defines an expired-cache exception and service declarations for cache timeout and transactional paging consistency; support and behavior depend on the service. OGC standard |
For shallow, low-change lists, offset paging may be sufficient. For deep traversal, use the deployed backend’s documented continuation approach and verify its ordering, lifetime, and consistency guarantees. OpenSearch’s scroll behavior and Elasticsearch’s recommendation are not interchangeable instructions; follow the documentation for the actual service and version in use.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.A practical debugging sequence
- Capture both requests. Log the normalized spatial input, filters, sort, page size, and offset or continuation state for each adjacent page.
- Compare returned identifiers and order. Determine whether the same identifier repeats, an expected identifier is absent, or the sequence has simply been re-ranked.
- Check request-to-cache association. Inspect whether the cache key varies with exact geometry, filters, sort, page size, and continuation state wherever those inputs affect the response.
- Check token and link continuity. Confirm the next link or token is used with the same query semantics and is still valid under the service’s documented expiry rules.
- Check index changes and sort ties. Look for writes between requests and confirm the sort is deterministic, adding a unique immutable tie-breaker if the backend supports it.
- Confirm snapshot expectations. Identify whether the API promises a stable view across pages and, if needed, switch to its supported snapshot or search-context mechanism.
These checks narrow down whether the symptom is caused by changing data, ordering, continuation misuse, cache-key omissions, or expiration. Without the application, backend, and request traces, they cannot establish a specific root cause.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchQuick Recap
Best Value
- Used Book in Good Condition
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.




