I built a crowdsourced deals + map app for Vietnam in 6 months — stack, traffic, and what broke

Architecting High-Volume Geo-Data Apps: ISR Optimization, Egress Control, and Affiliate Integration Patterns

Current Situation Analysis

Developers building location-based aggregators frequently underestimate the operational tax imposed by programmatic content generation. When an application scales from hundreds to tens of thousands of geo-tagged pages, the infrastructure costs shift from compute-heavy to metadata-heavy. The primary pain points are not rendering speed or database write throughput; they are metered API limits on static regeneration, database egress volume, and the fragility of third-party affiliate link structures.

This problem is often overlooked because initial development focuses on UI/UX and map rendering. Teams assume that Incremental Static Regeneration (ISR) and standard caching will handle scale linearly. In reality, ISR writes are metered per regeneration event, and database egress is metered per byte transferred. A common misconception is that HTTP compression reduces egress costs; however, compression only affects the final hop to the client, not the internal traffic between the application server and the database.

Data from production deployments of geo-aggregators reveals the severity of these blind spots. Applications with 40,000+ indexable location pages can consume 50% of a platform's monthly ISR write quota within 14 days if revalidation intervals are uniform. Similarly, uncached sitemap endpoints serving large payloads can generate 8GB of daily database egress, rapidly exhausting free-tier limits. Affiliate integration introduces a third vector of failure: nested tracking URLs from merchant networks often break deeplinking logic, causing silent 500 errors that go undetected until revenue impact is measured.

WOW Moment: Key Findings

The critical insight for scaling geo-aggregators is that content freshness must be tiered based on business value and update frequency, not applied uniformly. A tiered ISR strategy can reduce regeneration writes by over 85% while preserving SEO freshness for high-value deal pages.

Strategy	Monthly ISR Writes	SEO Freshness (Deal Pages)	Infrastructure Risk
Uniform 1-Hour Revalidate	~1,000,000+	High	Critical: Exceeds free tiers in weeks
Uniform 7-Day Revalidate	~180,000	Low: Stale deal data	Low: Safe, but hurts conversion
Tiered Context-Aware	~36,000	High: 1h for deals, 7d for locations	Low: Optimized cost/freshness balance

The tiered approach isolates the "write tax" to pages that drive immediate revenue, while static location data remains cached for longer periods. This pattern enables solo developers to maintain tens of thousands of pages on minimal infrastructure budgets.

Core Solution

Building a cost-effective geo-aggregator requires a monolithic architecture with feature-based modularity, aggressive caching at the API layer, and a robust affiliate link normalization pipeline. The recommended stack combines Next.js 14 for ISR and SEO, Spring Boot 3.2 with virtual threads for high-concurrency backend processing, and Supabase (PostgreSQL + PostGIS) for geo-spatial data.

1. Tiered ISR Configuration

Uniform revalidation is the primary cause of ISR write exhaustion. Implement a configuration-driven approach where revalidation intervals are defined per content type.

Architecture Decision: Use a centralized cache configuration module to export revalidation constants. This ensures consistency across route segments and allows dynamic adjustment without code changes.

// lib/cache-config.ts
export enum ContentCategory {
  LOCATION = 'location',
  DEAL_HUB = 'deal_hub',
  DAILY_DEAL = 'daily_deal',
  TOOL = 'tool'
}

export const REVALIDATION_STRATEGIES: Record<ContentCategory, number> = {
  [ContentCategory.LOCATION]: 604800,   // 7 days
  [ContentCategory.DEAL_HUB]: 21600,    // 6 hours
  [ContentCategory.DAILY_DEAL]: 3600,   // 1 hour
  [ContentCategory.TOOL]: 86400         // 24 hours
};

export function getRevalidate(category: ContentCategory): number {
  return REVALIDATION_STRATEGIES[category];
}

Apply this configuration in route segments. Location pages, which change infrequently, use the 7-day interval. Daily deal pages, which require freshness for SEO and conversion, retain the 1-hour interval.

// app/location/[slug]/page.tsx
import { getRevalidate, ContentCategory } from '@/lib/cache-config';

export const revalidate = getRevalidate(ContentCategory.LOCATION);

export default async function LocationPage({ params }: { params: { slug: string } }) {
  // Fetch location data...
}

2. Egress Gating with Redis Caching

Database egress spikes often originate from high-traffic endpoints like sitemaps or slug lists. These endpoints return large payloads and are frequently crawled by bots. Implement server-side caching with a distributed cache like Redis to intercept these requests.

Architecture Decision: Use Spring Boot's @Cacheable annotation with a Redis-backed cache manager. This moves the payload generation from the database to the cache, reducing egress to near-zero for repeated requests.

// com.geoapp.cache.SitemapCacheService.java
@Service
public class SitemapCacheService {

    private final LocationRepository locationRepository;

    public SitemapCacheService(LocationRepository locationRepository) {
        this.locationRepository = locationRepository;
    }

    @Cacheable(value = "sitemap-cache", key = "'active-slugs'", unless = "#result == null")
    public List<String> getActiveSlugs() {
        // Fetches 16MB+ payload from PostGIS
        return locationRepository.findAllActiveSlugs();
    }
}

On the frontend, configure the sitemap generation to respect the cache TTL.

// app/sitemap.ts
import { REVALIDATION_STRATEGIES, ContentCategory } from '@/lib/cache-config';

export default async function sitemap() {
  const res = await fetch(`${process.env.API_URL}/api/v1/locations/slugs`, {
    next: { revalidate: REVALIDATION_STRATEGIES[ContentCategory.DEAL_HUB] }
  });
  
  const slugs = await res.json();
  
  return slugs.map((slug: string) => ({
    url: `https://example.com/location/${slug}`,
    lastModified: new Date(),
  }));
}

3. Affiliate Link Normalization

Affiliate networks often wrap merchant URLs in their own tracking domains. Some merchants, however, use nested trackers from secondary networks. If the primary network's deeplinker encounters a nested tracker, it may fail with a 500 error. Implement a sanitizer that detects and unwraps nested trackers before passing the URL to the affiliate wrapper.

Architecture Decision: Create a dedicated AffiliateLinkSanitizer service. This service parses the URI, detects known tracker domains, and extracts the inner destination URL. This proactive normalization prevents silent failures.

// com.geoapp.affiliate.AffiliateLinkSanitizer.java
import java.net.URI;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;

public class AffiliateLinkSanitizer {

    private static final String NESTED_TRACKER_DOMAIN = "aff.redirect.net";
    private static final String INNER_URL_PARAM = "dest";

    public String sanitize(String rawUrl) {
        if (rawUrl == null || !rawUrl.contains(NESTED_TRACKER_DOMAIN)) {
            return rawUrl;
        }

        try {
            URI uri = URI.create(rawUrl);
            String query = uri.getQuery();
            if (query == null) return rawUrl;

            for (String param : query.split("&")) {
                String[] pair = param.split("=", 2);
                if (pair.length == 2 && INNER_URL_PARAM.equals(pair[0])) {
                    String innerUrl = URLDecoder.decode(pair[1], StandardCharsets.UTF_8);
                    return innerUrl.startsWith("http") ? innerUrl : "https://" + innerUrl;
                }
            }
        } catch (Exception e) {
            // Fallback to raw URL on parse error
            return rawUrl;
        }
        return rawUrl;
    }
}

4. Architecture Rationale

• Monolith over Microservices: For traffic volumes under 10k daily users, a monolith reduces operational complexity and cost. Feature-based packages (auth/, location/, deal/) provide modularity without the overhead of service mesh or distributed tracing.
• Spring Boot 3.2 with Virtual Threads: Virtual threads allow high concurrency with minimal memory overhead, ideal for I/O-bound operations like database queries and external API calls. This eliminates the need for complex reactive programming models while maintaining performance.
• PostGIS for Geo-Spatial Queries: Using PostGIS within Supabase avoids the cost of external geo-services. It enables efficient spatial indexing and queries for location-based features.
• REST over GraphQL: REST simplifies caching strategies and client implementation. For a map app with programmatic pages, REST endpoints align better with ISR and sitemap generation.

Pitfall Guide

1. ISR Write Explosion

   • Explanation: Applying a uniform revalidation interval to all pages causes write volumes to scale linearly with page count. High-frequency revalidation on static content wastes quota.
   • Fix: Implement tiered revalidation based on content category. Use 7-day intervals for stable data and 1-hour intervals for dynamic deal pages.

2. Egress vs. Compression Confusion

   • Explanation: Enabling HTTP compression reduces payload size to the client but does not reduce egress between the database and application server. Egress is measured at the database layer.
   • Fix: Cache large payloads at the API layer using Redis. Ensure the cache sits between the application and the database to intercept repeated requests.

3. Nested Affiliate Trackers

   • Explanation: Affiliate networks may wrap URLs that are already wrapped by secondary networks. The primary network's deeplinker may fail to process these nested structures, resulting in 500 errors.
   • Fix: Implement a link sanitizer that detects known tracker domains and extracts the inner URL before applying the affiliate wrapper.

4. Bot-Induced Egress on Sitemaps

   • Explanation: Sitemap endpoints are frequently crawled by search engine bots. If these endpoints return large payloads without caching, they generate massive egress volumes.
   • Fix: Cache sitemap data aggressively. Use revalidate on the frontend fetch and @Cacheable on the backend endpoint. Monitor bot traffic patterns.

5. Premature Microservices

   • Explanation: Splitting into microservices early adds complexity in deployment, monitoring, and inter-service communication. This increases costs and operational overhead without proportional benefits at low traffic.
   • Fix: Start with a monolith. Extract services only when specific components require independent scaling or when team size necessitates separation.

6. Missing PostGIS Indexes

   • Explanation: Geo-spatial queries without proper indexes degrade performance as data volume grows. Full table scans on location data cause slow response times.
   • Fix: Create GIST indexes on geometry columns. Use ST_DWithin for proximity queries and ensure indexes cover common filter patterns.

7. Map Provider Cost Surprise

   • Explanation: Google Maps pricing scales with usage and can become expensive for high-traffic map apps. Unexpected costs can arise from tile loads and API calls.
   • Fix: Use Mapbox or open-source alternatives like Leaflet with vector tiles. These providers offer more generous free tiers and predictable pricing models.

Production Bundle

Action Checklist

• Configure Tiered ISR: Define revalidation strategies per content category. Apply 7-day intervals for static pages and 1-hour intervals for dynamic deal pages.
• Implement Egress Caching: Add Redis caching for high-traffic endpoints like sitemaps and slug lists. Use @Cacheable on backend and revalidate on frontend.
• Deploy Affiliate Sanitizer: Create a link normalization service to unwrap nested trackers. Integrate this service before applying affiliate wrappers.
• Set Usage Alerts: Configure webhooks for Vercel ISR writes and Supabase egress. Trigger alerts at 50% and 80% of free-tier limits.
• Optimize JSON-LD: Implement structured data for LocalBusiness, Restaurant, and FAQPage. Use specific types to improve search visibility.
• Add PostGIS Indexes: Create GIST indexes on geometry columns. Verify query performance with EXPLAIN ANALYZE.
• Monitor Bot Traffic: Analyze server logs for bot patterns. Implement rate limiting or caching strategies for sitemap endpoints.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Map Provider Selection	Mapbox GL JS	Flexible, generous free tier, vector tiles. Avoids Google Maps cost scaling.	Low: Free tier covers moderate traffic.
Backend Hosting	Railway	Simple deployment for Spring Boot JAR. Predictable pricing.	Low: $5-10/month for small instances.
Database Strategy	Supabase (PostGIS)	Managed PostGIS, no ops overhead. Free tier includes egress.	Low: Free tier sufficient for initial scale.
Frontend Hosting	Vercel	Native Next.js support, ISR optimization.	Low: Free tier covers ISR writes with tiered config.
Caching Layer	Upstash Redis	Serverless Redis, free tier, easy integration.	Low: Free tier handles cache needs.

Configuration Template

Spring Boot Cache Configuration (application.yml)

spring:
  cache:
    type: redis
    redis:
      time-to-live: 21600000 # 6 hours in milliseconds
      cache-null-values: false
  data:
    redis:
      host: ${REDIS_HOST}
      port: ${REDIS_PORT}
      password: ${REDIS_PASSWORD}

Next.js Revalidation Helper (lib/revalidate-helper.ts)

export const CACHE_TTL = {
  SHORT: 3600,
  MEDIUM: 21600,
  LONG: 604800,
  VERY_LONG: 2592000
};

export function configureRevalidate(ttl: number) {
  return {
    revalidate: ttl,
    dynamic: 'force-static'
  };
}

Quick Start Guide

1. Initialize Project: Create a Next.js 14 app with TypeScript and a Spring Boot 3.2 project. Configure PostGIS in Supabase.
2. Setup Cache: Deploy Upstash Redis. Configure Spring Boot to use Redis for caching. Implement @Cacheable on heavy endpoints.
3. Define ISR Strategies: Create a cache configuration module. Define revalidation intervals for each content category. Apply to route segments.
4. Deploy Affiliate Sanitizer: Implement the link sanitizer service. Integrate with the affiliate link generation logic. Test with nested tracker URLs.
5. Monitor and Alert: Set up usage alerts for Vercel and Supabase. Monitor ISR writes and egress. Adjust revalidation intervals based on traffic patterns.