How We Built a Programmatic SEO Platform with 500+ Pages for Turkey's LED Lighting Industry

#nextjs #seo #typescript #webdev

Most SEO content is written one page at a time. We needed 500+ pages covering 81 cities, 7 venue types, 6 product categories, 7 calculators, pricing data, case studies, and a full industry glossary — all with consistent quality and real data.

Here's how we built isiklisusleme.com, a programmatic SEO platform for Turkey's Christmas LED lighting industry, using Next.js, TypeScript, and a content matrix strategy.

The Scale Problem

Turkey has 81 provinces. Each province has different LED lighting costs, different climate conditions, different vendor density, and different logistics considerations. On top of that, there are 7 major venue types (villas, malls, hotels, restaurants, retail, municipalities, heritage buildings), each with unique technical requirements and budget ranges.

If we wrote every page manually:

81 cities × 1 page each = 81 pages
7 venue types × 1 page each = 7 pages
6 product categories × 1 page each = 6 pages
Cross-matrix pages (city × venue) = hundreds more
Technical guides, pricing pages, calculators, case studies, glossary...

Total: 500+ pages of content that needs to be accurate, data-driven, and technically correct.

Manual content creation at this scale is impossible for a small team. But generic template-stuffing produces thin content that neither users nor search engines value.

We needed a middle path: programmatic generation with real data injection.

The Architecture

Content Matrix Design

The site's information architecture is built on intersecting content dimensions:

VENUES
├── Villa
├── AVM (Mall)
├── Hotel
├── Restaurant
├── Retail
├── Municipality
└── Heritage
×
CITIES (81) × PRODUCTS (6+)
├── Istanbul × ├── Pro LED strings
├── Ankara × ├── Silicone LED strip
├── Izmir × ├── RGB animated
├── Antalya × ├── Net/mesh LED
├── Bursa × ├── Smart LED + IoT
├── ... × └── Solar garden
└── 76 more ×
×
PRICING × GUIDES × CALCULATORS

Each intersection produces a unique page with data specific to that combination.

Next.js Dynamic Routes

// app/sehir/[slug]/page.tsx
// Generates 81 city-specific LED lighting guides

interface CityData {
  name: string;
  slug: string;
  region: string;
  climate: ClimateProfile;
  avgCostMultiplier: number;
  vendorDensity: 'high' | 'medium' | 'low';
  logisticsCost: number;
  specialConsiderations: string[];
}

export async function generateStaticParams() {
  // All 81 Turkish provinces
  return cities.map(city => ({ slug: city.slug }));
}

export default function CityPage({ params }: { params: { slug: string } }) {
  const city = getCityData(params.slug);

  return (
    <article>
      <h1>{city.name} Yılbaşı Işık Süsleme Rehberi</h1>

      {/* Data-driven sections */}
      <PricingSection city={city} />
      <ClimateSection climate={city.climate} />
      <VendorDensitySection density={city.vendorDensity} />
      <LogisticsSection cost={city.logisticsCost} />
      <IPRatingRecommendation climate={city.climate} />

      {/* Venue-specific subsections */}
      {venues.map(venue => (
        <VenueSection 
          key={venue.slug}
          venue={venue}
          city={city}
          adjustedPricing={calculateCityPricing(venue.basePricing, city.avgCostMultiplier)}
        />
      ))}
    </article>
  );
}

Data Layer: City-Specific Pricing

Each city page shows adjusted pricing based on real market factors:

interface PricingFactors {
  baseCost: number;           // Istanbul baseline
  logisticsMultiplier: number; // Distance from supplier hubs
  laborCostIndex: number;      // Regional labor rates
  competitionDiscount: number;  // More vendors = lower margins
  climateAdjustment: number;   // Harsh weather = higher IP rating = higher cost
}

function calculateCityPricing(
  baseVenuePricing: VenuePricing,
  cityFactors: PricingFactors
): AdjustedPricing {
  const multiplier = 
    cityFactors.logisticsMultiplier *
    cityFactors.laborCostIndex *
    (1 - cityFactors.competitionDiscount) *
    cityFactors.climateAdjustment;

  return {
    min: Math.round(baseVenuePricing.min * multiplier),
    max: Math.round(baseVenuePricing.max * multiplier),
    typical: Math.round(baseVenuePricing.typical * multiplier),
    currency: 'TRY',
    year: 2026
  };
}

This means the Antalya villa lighting page shows different budget ranges than the Erzurum villa lighting page — because logistics, labor, and climate considerations are genuinely different.

Calculator Architecture: Client-Side Only

Seven interactive calculators run entirely in the browser:

// Facade measurement calculator
// Zero server calls — all computation in TypeScript

interface FacadeInput {
  buildingWidth: number;    // meters
  buildingHeight: number;   // meters
  floors: number;
  windowCount: number;
  windowAvgWidth: number;   // meters
  windowAvgHeight: number;  // meters
  rooflineLength: number;   // meters
  includeRoofline: boolean;
  includeWindows: boolean;
  ledDensity: 'sparse' | 'standard' | 'dense';
}

interface FacadeResult {
  totalLinearMeters: number;
  adjustedMeters: number;  // after waste factor
  estimatedLEDStrings: number;
  estimatedTransformers: number;
  estimatedWattage: number;
  priceRange: { min: number; max: number };
}

function calculateFacade(input: FacadeInput): FacadeResult {
  // Perimeter calculation
  const perimeter = (input.buildingWidth + input.buildingHeight) * 2;
  const facadeArea = input.buildingWidth * input.buildingHeight;

  // Window deduction
  const windowArea = input.includeWindows 
    ? 0 
    : input.windowCount * input.windowAvgWidth * input.windowAvgHeight;

  // Roofline addition
  const roofline = input.includeRoofline ? input.rooflineLength : 0;

  // Density multiplier
  const densityFactor = {
    sparse: 0.7,
    standard: 1.0,
    dense: 1.4
  }[input.ledDensity];

  // Linear meters calculation
  const baseMeters = (perimeter * input.floors) + roofline;
  const totalLinearMeters = baseMeters * densityFactor;

  // 15% waste factor for cuts, corners, returns
  const adjustedMeters = Math.ceil(totalLinearMeters * 1.15);

  // Product calculations
  const metersPerString = 10; // standard LED string length
  const wattsPerMeter = 4.8; // standard LED consumption
  const wattsPerTransformer = 150;

  const estimatedLEDStrings = Math.ceil(adjustedMeters / metersPerString);
  const estimatedWattage = adjustedMeters * wattsPerMeter;
  const estimatedTransformers = Math.ceil(estimatedWattage / wattsPerTransformer);

  // Price range (2026 market rates)
  const pricePerMeter = { min: 45, max: 180 }; // TRY

  return {
    totalLinearMeters: Math.round(totalLinearMeters),
    adjustedMeters,
    estimatedLEDStrings,
    estimatedTransformers,
    estimatedWattage: Math.round(estimatedWattage),
    priceRange: {
      min: adjustedMeters * pricePerMeter.min,
      max: adjustedMeters * pricePerMeter.max
    }
  };
}

Privacy benefit: since calculations run client-side, we never see what buildings users are measuring or what budgets they're working with.

Structured Data at Scale

Every page type gets appropriate Schema.org markup generated programmatically:

// Generate schema based on page type
function generatePageSchema(pageType: string, data: any) {
  switch (pageType) {
    case 'city':
      return {
        '@context': 'https://schema.org',
        '@type': 'Article',
        headline: `${data.cityName} Yılbaşı Işık Süsleme Rehberi`,
        author: { '@type': 'Person', name: 'İsmail Günaydın' },
        publisher: { '@type': 'Organization', name: 'isiklisusleme.com' },
        datePublished: data.publishDate,
        dateModified: data.updateDate,
        about: {
          '@type': 'City',
          name: data.cityName,
          containedIn: { '@type': 'Country', name: 'Turkey' }
        }
      };

    case 'calculator':
      return {
        '@context': 'https://schema.org',
        '@type': 'WebApplication',
        name: data.calculatorName,
        applicationCategory: 'BusinessApplication',
        operatingSystem: 'Any',
        offers: { '@type': 'Offer', price: '0', priceCurrency: 'TRY' }
      };

    case 'pricing':
      return {
        '@context': 'https://schema.org',
        '@type': 'Article',
        headline: data.title,
        author: { '@type': 'Person', name: 'İsmail Günaydın' },
        dateModified: data.updateDate
      };

    case 'glossary':
      return {
        '@context': 'https://schema.org',
        '@type': 'DefinedTermSet',
        name: 'LED Işıklandırma Sözlüğü',
        hasDefinedTerm: data.terms.map(term => ({
          '@type': 'DefinedTerm',
          name: term.name,
          description: term.definition
        }))
      };
  }
}

Internal Linking Strategy

With 500+ pages, internal linking becomes critical for both SEO and user navigation:

// Automatic contextual internal links
function generateRelatedLinks(currentPage: PageData): RelatedLink[] {
  const links: RelatedLink[] = [];

  // Same city, different venues
  if (currentPage.type === 'city') {
    venues.forEach(venue => {
      links.push({
        text: `${currentPage.cityName} ${venue.name} süsleme`,
        href: `/sehir/${currentPage.slug}/${venue.slug}`
      });
    });
  }

  // Same venue, nearby cities
  if (currentPage.type === 'venue') {
    const nearbyCities = getNearbyCities(currentPage.citySlug, 3);
    nearbyCities.forEach(city => {
      links.push({
        text: `${city.name} ${currentPage.venueName}`,
        href: `/sehir/${city.slug}`
      });
    });
  }

  // Always link to relevant calculator
  const relevantCalc = getRelevantCalculator(currentPage);
  if (relevantCalc) {
    links.push({
      text: `${relevantCalc.name} hesaplayıcı`,
      href: `/hesaplayici/${relevantCalc.slug}`
    });
  }

  // Always link to relevant pricing page
  const relevantPricing = getRelevantPricing(currentPage);
  if (relevantPricing) {
    links.push({
      text: `${relevantPricing.name} fiyat bilgisi`,
      href: `/fiyat/${relevantPricing.slug}`
    });
  }

  return links;
}

Content Quality at Scale

The biggest risk with programmatic SEO is thin content — pages that technically exist but provide no real value. We avoid this with three strategies:

Real data injection. Every city page has genuinely different pricing data, climate considerations, and logistics factors. It's not the same text with city names swapped.

Human-written section templates. The templates themselves are detailed and informative. The programmatic layer injects data points, but the explanatory text around those data points is written once, carefully, by a human.

Unique sections for premium pages. High-traffic pages (Istanbul, Ankara, Izmir, Antalya) get manually written additional sections — neighborhood-level detail, specific case studies, and local vendor landscape analysis that can't be generated programmatically.

Performance Results

Six months after launch:

Metric	Value
Total indexed pages	500+
Organic keywords ranking	2,000+
Average page load	< 1.5s
Core Web Vitals	All green
City pages generating traffic	65 of 81

The long-tail strategy works: individual city pages each bring small amounts of traffic, but collectively they represent the majority of organic visits.

Key Takeaways

Programmatic SEO needs real data differentiation. Swapping city names in identical templates produces thin content. Each page needs genuinely different data points.
Calculators are link magnets. The facade measurement calculator and cost estimator generate the most backlinks and longest session durations.
Client-side calculators = privacy + performance. No server calls means instant results and zero data collection concerns.
Schema.org at scale requires type-aware generation. Different page types need different schema — Article for guides, WebApplication for calculators, DefinedTermSet for glossaries.
Internal linking compounds. With 500+ pages, every new page strengthens the internal link network for existing pages.

Links:

🌐 isiklisusleme.com
📚 Rehberler
🧮 Hesaplayıcılar
💰 Fiyatlar
🌍 81 İl
📊 Crunchbase
💼 LinkedIn
📘 Facebook
📺 YouTube
✍️ Medium