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
İsmail Günaydın — Founder of isiklisusleme.com. Full-stack web engineer building data-driven platforms. LinkedIn · Portfolio