DEV Community: İsmail Günaydın

The Algorithm of Authority: What Game Theory Teaches Us About GEO, Systems, and "Costly Signaling"

İsmail Günaydın — Thu, 04 Jun 2026 18:31:22 +0000

If you analyze the mechanics of high-end retail management and compare them to the algorithms driving modern search engines, you will find they execute the exact same core function: verifying trust through "Costly Signaling."

Whether you are orchestrating AI agents for rapid development, deploying scalable architectures on Vercel with Next.js, or trying to make your data visible to LLM-driven search bots, the goal is to build system consensus. Behavioral economics—specifically Michael Suk-Young Chwe’s theory of "Common Knowledge"—provides the perfect mental model for understanding how both human crowds and AI algorithms assign authority.

Here is how the behavioral psychology of the physical world maps directly to digital architecture, Generative Engine Optimization (GEO), and the future of search.

The Physical Node: Costly Signaling in the Real World
In game theory and evolutionary biology, a "costly signal" is an action that requires so much energy or resources that it proves the actor is undeniably strong. You cannot fake a costly signal.

In the physical world, commercial architecture relies heavily on this. A premium destination doesn't just put up a sign; it alters its environment. Think about the infrastructure required for professional intersection lighting or a massive, city-wide tree lighting service. These are hardware-level costly signals.

When a municipality or commercial entity deploys a large-scale led lighting service, they are broadcasting stability and prosperity. Visitors process this visual data and reach a consensus: this is a premium, safe, and authoritative environment. It creates "Common Knowledge"—everyone knows it's the center of attention, and everyone knows that everyone else knows it.

The Digital Equivalent: Entity Stacking and GEO
As the web transitions from traditional search to AI-driven Answer Engine Optimization (AEO) and Generative Engine Optimization (GEO), search bots like ChatGPT, Perplexity, and Gemini are acting like consumers scanning a physical space. They are looking for digital costly signals.

AI bots do not just read text; they look for Entity Stacking. They cross-reference the depth, accuracy, and structure of your data to determine if you are a genuine authority. Just as a commercial space might use highly durable, commercial-grade icicle led lights rather than cheap alternatives to signal quality, your digital architecture must signal its depth.

When you publish highly technical content, structure your schema perfectly, and build a connected web of verifiable entities, you are sending a costly signal to the crawler. You are proving that you have invested the resources to be the definitive source.

Vibe Coding the "Common Knowledge"
The concept of Common Knowledge is ultimately about shared reality. In software engineering, especially when utilizing vibe coding with tools like Cursor or Claude Code, we can rapidly generate the frontend and backend structures required to broadcast these signals.

However, the logic of the signal must remain sound. If you are building an e-commerce platform for seasonal transitions, such as spring decoration, the UI, the semantic HTML, the fast load times via Next.js, and the strategic deployment of keywords all serve as interconnected nodes. If one node fails, the signal degrades. If the nodes operate in harmony—like a perfectly synchronized array of led string lights—the system achieves high availability and absolute user trust.

Conclusion: You Cannot Fake the Signal
The bridge between physical retail dominance and digital search visibility is built on the same foundational truth: authority must be proven. Whether you are illuminating a physical storefront to create a localized monopoly on foot traffic, or structuring your databases to dominate an AI's context window, success requires a deliberate, undeniable investment in your infrastructure.

Build the costly signal. Establish the common knowledge. The traffic—both human and algorithmic—will follow.


![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pn0de3b9bwiy102fa348.jpeg)

Structured Data for AI Search: A Practical Schema.org Setup in Next.js

İsmail Günaydın — Wed, 03 Jun 2026 22:08:28 +0000

AI assistants like ChatGPT, Gemini, Perplexity, and Google's AI Overviews are increasingly answering questions by citing structured data on the page. If your product or content site is not emitting clean Schema.org JSON-LD, you are invisible to that layer of search.

This post walks through the exact pattern I use across all 19 product pages on toolgenx.com - a Next.js storefront built for AI search visibility from day one.

Why Structured Data Matters Now

Classic SEO rewards keyword relevance and backlinks. AI search rewards something different: machine-readable claims about entities.

When an LLM cites a source, it favors pages where the facts are explicit, well-structured and verifiable. JSON-LD is the lowest-cost way to expose those facts.

If a model has to guess what your page is about, it skips you. If your page tells the model exactly what it is, who built it, what it costs, and how it relates to other entities, you become citable.

The Three Schemas Every Product Page Needs

For a digital product storefront, three Schema.org types do most of the work:

Organization - the brand entity
Product - each individual product
BreadcrumbList - the page's position in your site hierarchy

You add these once per page as a single <script type="application/ld+json"> tag.

Implementation in Next.js (App Router)

Here is a minimal but production-ready pattern. Place this in your product page component:

// app/products/[slug]/page.tsx

export default function ProductPage({ params }: { params: { slug: string } }) {
  const product = getProduct(params.slug);

  const jsonLd = {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "Organization",
        "@id": "https://www.toolgenx.com/#organization",
        "name": "ToolGenX",
        "url": "https://www.toolgenx.com",
        "logo": "https://www.toolgenx.com/logo.png",
        "sameAs": [
          "https://www.facebook.com/toolgenx",
          "https://www.linkedin.com/company/toolgenx",
          "https://youtube.com/@toolgenx"
        ]
      },
      {
        "@type": "Product",
        "name": product.name,
        "description": product.description,
        "brand": { "@id": "https://www.toolgenx.com/#organization" },
        "category": product.category,
        "offers": {
          "@type": "Offer",
          "price": product.price,
          "priceCurrency": "USD",
          "availability": "https://schema.org/InStock",
          "url": `https://www.toolgenx.com/products/${params.slug}`
        }
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://www.toolgenx.com" },
          { "@type": "ListItem", "position": 2, "name": "Products", "item": "https://www.toolgenx.com/products" },
          { "@type": "ListItem", "position": 3, "name": product.name }
        ]
      }
    ]
  };

  return (
    <>
      <script
        type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
      />
      {/* rest of your product page */}
    </>
  );
}

Three Patterns That Make a Difference

1. Use @graph instead of nesting

A single @graph array is cleaner than deeply nested objects. It also makes it trivial to add new entities later (Article, FAQPage, Review) without restructuring.

2. Reuse the Organization node with @id

Define your Organization once, give it an @id, and reference it from every Product. This tells crawlers "all these products belong to the same brand entity" - critical for entity consolidation.

3. Match sameAs to your real profile chain

The sameAs array is how you tell search engines and LLMs which social profiles belong to your brand. Inconsistency here weakens the entity. Make sure the URLs match exactly what's on each platform.

Validating Your Output

Three tools that catch real issues:

Google Rich Results Test - validates against Google's specific rules
Schema.org Validator - validates raw Schema.org compliance
View page source and search for application/ld+json to confirm it's actually rendered (Next.js sometimes silently drops it during hydration if you place it wrong)

What This Unlocks

Once your structured data is clean:

Google can render rich results (price, availability, ratings)
AI search engines have a verifiable source to cite
Your sameAs chain consolidates entity authority across platforms
You become discoverable in queries you never explicitly targeted

For ToolGenX, the practical outcome was direct: product pages started getting cited in AI-generated answers within weeks of implementing this. Not because the products changed, but because the page finally told the truth in a format machines could parse.

Going Further

If you want a production-ready library of Schema.org templates for products, articles, FAQs, breadcrumbs, organizations, local businesses, courses, events, reviews, and more - all pre-built and ready to drop into Next.js - I packaged the patterns into the Structured Data Pro Pack on ToolGenX.

It is the same library running across all 19 product pages on toolgenx.com.

ToolGenX builds practical AI toolkits and digital products for solo founders, indie developers and small teams. 19 products across 7 categories. Browse the catalog at toolgenx.com/products.

Profesyonel Yılbaşı Işık Süsleme ve LED Dekorasyon Firması

İsmail Günaydın — Mon, 01 Jun 2026 14:27:51 +0000

How to Choose the Right LED Lighting Company for Christmas and Seasonal Projects
Choosing the right LED lighting and decoration company for Christmas, Ramadan, or other seasonal projects is more important than most businesses realize. A poorly executed lighting project can lead to high energy costs, frequent breakdowns, facade damage, and customer complaints during the busiest time of the year.
In this article, I’ll share the key factors you should consider when selecting a professional lighting company, based on years of experience in large-scale projects across Turkey.

Check if They Have In-House Production Many companies outsource their LED products and only handle installation. This creates several problems:

Slow spare parts supply when something breaks
Lower quality control
Longer warranty claim processes

Companies with their own production facility can control quality better, offer faster support, and usually provide more reliable products (especially IP68 rated items that go through tank testing).

IP Rating and Durability Standards Outdoor LED lighting must withstand rain, snow, wind, and temperature changes. Many cheap solutions use IP65 or lower protection, which often fails during the season. Professional companies use IP68 products that have passed strict waterproof and dustproof tests. This significantly reduces mid-season failures and maintenance costs.
Damage-Free Installation Methods Especially for villas, historic buildings, and premium commercial properties, traditional installation methods (drilling, screwing) can cause permanent damage to the facade. Look for companies that use patented damage-free mounting systems. These systems allow installation without drilling or damaging the surface, which protects your property and avoids future repair costs.
Clear Warranty and Fast Response Time “2 years warranty” sounds good on paper, but what matters is how quickly they respond when something goes wrong. Professional companies offer:

Written warranty terms
48-hour on-site response commitment
Clear after-sales support process

Ask specifically: “If a light fails in December, how fast can you fix it?”

Transparent Pricing and Energy Consumption Planning Some companies give very low initial quotes but don’t clearly explain electricity consumption or hidden costs. A professional company should provide:

Clear pricing breakdown
Energy consumption estimates
Optional tools to calculate total seasonal cost

This helps you avoid surprise electricity bills after the project is finished.

Experience with Similar Projects Not every lighting company has experience with large-scale projects like shopping malls, municipalities, or luxury villas. Ask for references and photos of similar projects they have completed in the past 1–2 years. Experience with high-voltage work, night installations (for malls), and municipal tender processes makes a big difference in project quality and smoothness. Final Recommendation A good LED lighting company should combine:

In-house production
IP68 certified products
Damage-free installation methods
Strong written warranty + fast response
Transparent pricing and technical planning

When these elements come together, you get fewer problems, better visuals, and lower long-term costs.
If you are planning a Christmas, Ramadan, or any seasonal lighting project and want professional support, you can explore services and tools here:

All Services: https://www.ledisiklandirma.com/hizmetler
Price Calculator: https://www.ledisiklandirma.com/yilbasi-isik-susleme-fiyat-hesaplama
LED Cost Calculator: https://www.ledisiklandirma.com/led-isik-susleme-maliyet-hesaplayici
Get a Quote: https://www.ledisiklandirma.com/teklif-al

Have you faced any of these issues in previous lighting projects? Feel free to share your experience in the comments.

How to Choose the Right Bra and Lingerie: Common Mistakes Women Make and How to Fix Them

İsmail Günaydın — Sun, 31 May 2026 21:10:43 +0000

Choosing the right lingerie is not just about aesthetics. It directly affects comfort, posture, confidence, and even long-term health. Unfortunately, many women continue to wear the wrong size or low-quality pieces for years without realizing the negative effects.
In this article, I’ll break down the most common lingerie mistakes and share practical solutions to help you make better choices.

Wearing the Wrong Bra Size for Years This is by far the most common mistake. Many women stick to the same bra size for 5–10 years, even though their body goes through natural changes due to weight fluctuations, pregnancy, breastfeeding, or aging. Wearing the wrong size can cause:

Back and shoulder pain
Poor posture
Skin irritation
Lack of proper support

Solution: Get professionally measured at least once a year. Even a small change in your measurements can significantly improve comfort and support.

Prioritizing Style Over Comfort Sexy lingerie is great for special occasions, but daily wear requires a different approach. Many women choose beautiful designs that dig into the skin, slip throughout the day, or offer zero support. While aesthetics matter, comfort should be the priority for everyday pieces. Breathable fabrics like cotton, modal, and high-quality blends perform much better for long hours of wear.
Ignoring Your Body Type Not every bra style suits every body type. For example:

Women with larger busts usually need stronger support and wider straps.
Women with smaller busts may prefer lighter, more flexible options.
Body shape also affects how certain cuts (balconette, plunge, minimizer, etc.) look and feel.

Choosing styles that complement your natural shape makes a big difference in both appearance and comfort.

Buying Cheap Lingerie That Doesn’t Last Low-cost lingerie often uses poor quality materials and weak elastic. These pieces lose their shape quickly, fade after a few washes, and can even cause skin irritation. While it’s tempting to buy multiple cheap items, investing in better quality pieces usually saves money in the long run because they last significantly longer and maintain their shape and support.
Not Replacing Lingerie Regularly Even high-quality bras lose elasticity over time. Most experts recommend replacing bras every 6–12 months, depending on how often you wear them. Continuing to wear stretched-out bras reduces support and can affect your posture and comfort.
Not Considering Fabric Quality and Breathability Synthetic fabrics that don’t breathe can cause sweating, odor, and skin irritation — especially in hot weather or during physical activity. Natural or high-quality blended fabrics (cotton, modal, Tencel) are generally much better for daily wear and skin health. Final Thoughts Choosing the right lingerie is a combination of proper fit, suitable materials, and understanding your body’s needs. Small changes in how you shop for innerwear can lead to major improvements in comfort and confidence. If you’re looking for quality options with good support and comfortable fabrics, you can explore collections here:

Bra Collection: https://www.lunaintim.com/kategori/sutyen
Bottoms & Panties: https://www.lunaintim.com/kategori/kulot
Sleepwear & Loungewear: https://www.lunaintim.com/kategori/pijama
Beden Rehberi (Size Guide): https://www.lunaintim.com/beden-rehberi
Blog & Guides: https://www.lunaintim.com/blog

Have you experienced any of these issues with your current lingerie? Feel free to share your thoughts in the comments.

Türkiye'nin En Profesyonel Işıklandırma ve Yılbaşı Işık Süsleme Firması

İsmail Günaydın — Sat, 30 May 2026 18:27:56 +0000

Dış mekan LED ışıklandırma projelerinde en kritik konulardan biri, ürünlerin gerçek saha koşullarına ne kadar dayanabileceğidir. Birçok işletme (AVM, otel, villa, belediye) yılbaşı veya etkinlik sezonu için ışıklandırma yaptırırken sadece görselliğe odaklanıyor. Ancak teknik detaylar doğru yapılmadığında sezon ortasında arızalar, yüksek bakım maliyeti ve müşteri memnuniyetsizliği kaçınılmaz oluyor.
Bu yazıda, dış mekan LED sistemlerinde en önemli teknik kriterleri, IP koruma sınıflarını, montaj tekniklerini ve profesyonel kurulum sürecini detaylı şekilde ele alacağım.
IP Koruma Sınıfları Neden Bu Kadar Önemli?
Dış mekanda kullanılan LED ürünler sürekli yağmur, kar, toz, rüzgar ve sıcaklık değişimlerine maruz kalır. IP (Ingress Protection) kodu, ürünün katı parçacıklara ve suya karşı koruma seviyesini gösterir.
En sık kullanılan sınıflar:

IP65: Toza karşı korumalı, düşük basınçlı su jetlerine dayanıklı. Birçok ucuz üründe bu sınıf kullanılır. Ancak yoğun yağmur ve kar altında uzun vadede sorun çıkarabilir.
IP66 / IP67: Daha yüksek su koruması. Kısa süreli su altında kalma durumlarına dayanır.
IP68: En yüksek seviye. Toz geçirmez + sürekli su altında kalma testinden geçmiş. Profesyonel dış mekan projelerinde tercih edilen standarttır.

IP68 ürünleri genellikle özel tank testlerinden geçirilir. Bu test, ürünün gerçek saha koşullarına ne kadar hazır olduğunu gösterir.
Dış Mekan LED Ürün Tipleri ve Teknik Özellikleri
Farklı mekanlar için farklı LED tipleri kullanılır:

Dikey Perde LED: AVM ve plaza cepheleri için idealdir. Modüler yapıda, RGB veya tek renk seçenekli, genellikle 24V çalışma gerilimi.
Hortum LED: Çatı kenarları, balkon korkulukları ve vitrin çerçeveleri için uygundur. Silikon kılıflı ve UV dayanıklıdır.
İpsi LED (Ağaç Sarım): Villa ve site bahçelerinde ağaç gövdeleri için kullanılır. Kauçuk korumalı sarım tekniği ile rüzgara dayanıklı hale getirilir.
Çığ / Meteor LED: Cephe vurguları ve vitrinlerde hareket efekti için tercih edilir.
Motif LED: Cadde ve belediye projelerinde direk aralarında kullanılır. Rüzgar mukavemeti yüksek olmalıdır.

Doğru ürün seçimi, mekanın ihtiyacına ve teknik şartlara göre yapılmalıdır.
Profesyonel Kurulumda Dikkat Edilmesi Gereken Teknik Detaylar
Teknik olarak güçlü bir kurulum için şu unsurlar kritik:

Voltaj Seçimi: Çoğu profesyonel sistem 24V kullanır. Daha güvenli ve uzun ömürlüdür.
Kablo ve Bağlantı Kalitesi: UV dayanıklı, kauçuk korumalı kablolar kullanılmalıdır.
Montaj Sistemi: Patentli hasarsız kelepçe sistemleri tercih edilmelidir. Delik delme veya vida atma yöntemleri cepheye zarar verir.
Elektrik Altyapısı: Proje öncesi elektrik tüketim hesabı yapılmalı ve altyapı buna göre güçlendirilmelidir.
Güvenlik: Yüksek katlarda ÇSGB belgeli ekipler ve vinçli kurulum zorunludur.

Profesyonel firmalar kurulum öncesi teknik şartname hazırlar ve 3D tasarım onayı alır.
Neden Kendi Üretimi Olan Firma Tercih Edilmeli?
Birçok firma dışarıdan ürün alıp monte eder. Bu durumda:

Arıza durumunda parça temini yavaş olur
Kalite kontrolü zayıf kalır
Garanti süreci uzar

Kendi atölyesinde üretim yapan firmalar (IP68 tank testi yapan, her ürüne takip numarası veren) hem daha hızlı hem daha güvenilirdir. Üretim sürecini kontrol ettikleri için teknik standartlar daha yüksektir.
Garanti ve Bakım Süreci
Profesyonel bir projede garanti sadece “2 yıl” demek değildir. Gerçek anlamda:

Yazılı sözleşmede net taahhüt
48 saat içinde sahada müdahale
Sezon sonunda söküm + etiketli saklama
Gelecek yıl indirimli yeniden kurulum

Bu süreç hem maliyet avantajı sağlar hem de uzun vadeli sorunsuz kullanım imkanı verir.
Sonuç
Dış mekan LED ışıklandırma projelerinde başarı, sadece güzel görünen bir kurulumla değil, teknik detayların doğru yönetilmesiyle elde edilir. IP68 standartı, doğru ürün seçimi, hasarsız montaj, güçlü garanti ve profesyonel kurulum süreci bir arada olduğunda hem estetik hem de uzun ömürlü sonuçlar alınır.
Eğer dış mekan ışıklandırma projenizde teknik detaylara önem veriyor ve profesyonel bir süreç istiyorsanız, aşağıdaki linklerden detaylı bilgi alabilirsiniz:

LED Işık Süsleme Hizmetleri: https://www.a1organizasyon.com/hizmetlerimiz/led-isik-susleme
Teknik Standartlar: https://www.a1organizasyon.com/teknik-standartlar
İş Güvenliği ve Sigorta: https://www.a1organizasyon.com/is-guvenligi-sigorta
Uygulama Metodolojimiz: https://www.a1organizasyon.com/uygulama-metodolojimiz
Yılbaşı Işık Süsleme: https://www.a1organizasyon.com/hizmetlerimiz/yilbasi-isik-suslemeleri
Hemen Teklif Almak İçin: https://www.a1organizasyon.com/teklif-al

Deneyimlerinizi veya teknik sorularınızı yorumlarda paylaşabilirsiniz.
İsmail Günaydın
A1 Organizasyon

Yılbaşı Işık Süsleme ve Uygulama, Ağaç Led Işıklandırma

İsmail Günaydın — Sat, 30 May 2026 16:56:52 +0000

Dış Mekan LED Işıklandırma: IP Koruma Sınıfları, Teknik Özellikler ve Profesyonel Kurulum Rehberi
Dış mekan LED ışıklandırma projelerinde en kritik konulardan biri, ürünlerin gerçek dünya koşullarına ne kadar dayanabileceğidir. Birçok işletme (AVM, otel, villa, site, belediye) yılbaşı veya etkinlik sezonu için ışıklandırma yaptırırken sadece görselliğe odaklanıyor. Ancak teknik detaylar doğru yapılmadığında sezon ortasında arızalar, yüksek bakım maliyeti ve müşteri memnuniyetsizliği kaçınılmaz oluyor.
Bu yazıda, dış mekan LED sistemlerinde en önemli teknik kriterleri, IP koruma sınıflarını, doğru ürün seçimini ve profesyonel kurulum sürecini detaylı şekilde ele alacağım.
IP Koruma Sınıfları Neden Bu Kadar Önemli?
Dış mekanda kullanılan LED ürünler sürekli yağmur, kar, toz, rüzgar ve sıcaklık değişimlerine maruz kalır. IP (Ingress Protection) kodu, ürünün katı parçacıklara ve suya karşı koruma seviyesini gösterir.
En sık kullanılan sınıflar:

Dikey Perde LED: AVM ve plaza cepheleri için idealdir. Modüler yapıda (1x2m, 2x2m, 3x3m), RGB veya tek renk seçenekli, 24V çalışma gerilimi.
Hortum LED: Çatı kenarları, balkon korkulukları ve vitrin çerçeveleri için uygundur. Silikon kılıflı, UV dayanıklı, 12V/220V seçenekli.
İpsi LED (Ağaç Sarım): Villa ve site bahçelerinde ağaç gövdeleri için kullanılır. Kauçuk korumalı sarım tekniği ile rüzgara dayanıklı hale getirilir.
Çığ / Meteor LED: Cephe vurguları ve vitrinlerde hareket efekti için tercih edilir. Programlanabilir flaş efekti vardır.
Motif LED: Cadde ve belediye projelerinde direk aralarında kullanılır. Rüzgar mukavemeti yüksek olmalıdır.

Doğru ürün seçimi, mekanın ihtiyacına ve teknik şartlara göre yapılmalıdır. Yanlış ürün seçimi hem estetik hem de dayanıklılık açısından sorun yaratır.
Profesyonel Kurulumda Dikkat Edilmesi Gereken Teknik Detaylar
Teknik olarak güçlü bir kurulum için şu unsurlar kritik:

Arıza durumunda parça temini yavaş olur
Kalite kontrolü zayıf kalır
Garanti süreci uzar

Yazılı sözleşmede net taahhüt
48 saat içinde sahada müdahale
Sezon sonunda söküm + etiketli saklama
Gelecek yıl %25 indirimli yeniden kurulum

Bu süreç hem maliyet avantajı sağlar hem de uzun vadeli sorunsuz kullanım imkanı verir.
Sonuç
Dış mekan LED ışıklandırma projelerinde başarı, sadece güzel görünen bir kurulumla değil, teknik detayların doğru yönetilmesiyle elde edilir. IP68 standartı, doğru ürün seçimi, hasarsız montaj, güçlü garanti ve profesyonel kurulum süreci bir arada olduğunda hem estetik hem de uzun ömürlü sonuçlar alınır.
2026 yılbaşı sezonu için erken rezervasyonlar devam ediyor. Teknik detayları önemseyen, şeffaf çalışan ve kendi üretimi olan ekiplerle çalışmak, projenizin başarısını doğrudan etkiler.
Deneyimlerinizi veya teknik sorularınızı yorumlarda paylaşabilirsiniz.
İsmail Günaydın
Dış Mekan Süsleme
Kaynaklar:

Yılbaşı Işık Süsleme: https://www.dismekansusleme.com/sezon/yilbasi-susleme
Firma Seçme Rehberi: https://www.dismekansusleme.com/rehber/nasil-secilir
Bütçe ve Teknik Hesaplamalar: https://www.dismekansusleme.com/hesapla
Portfolyo: https://www.dismekansusleme.com/portfolyo
Teklif Al: https://www.dismekansusleme.com/teklif-al

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

İsmail Günaydın — Tue, 12 May 2026 19:05:29 +0000

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

How We Built a Real-Time Text Analysis Engine That Processes Every Keystroke in Under 1ms

İsmail Günaydın — Mon, 20 Apr 2026 16:16:55 +0000

When a user pastes 10,000 words into a text area and starts editing, every keystroke needs to update 20+ metrics simultaneously: words, characters, sentences, paragraphs, syllables, unique words, reading time, speaking time, keyword density, reading level, longest sentence, shortest sentence, average word length, and more.

If any of these calculations take longer than 16ms (one frame at 60fps), the user sees jank — a visible stutter in the typing experience. For a writing tool, that's unacceptable.

At TextWordCount, we process all 20+ metrics on every keystroke in under 1ms for texts up to 50,000 words. Here's how.

The Naive Approach (And Why It Fails)

The obvious implementation splits text on spaces, counts the result, and calls it done:

// ❌ Naive approach — breaks on edge cases, slow on large texts
function countWords(text: string): number {
  return text.split(' ').filter(w => w.length > 0).length;
}

function countSentences(text: string): number {
  return text.split(/[.!?]/).filter(s => s.trim().length > 0).length;
}

function countSyllables(text: string): number {
  // Running regex on every word on every keystroke...
  return text.split(' ')
    .map(word => countWordSyllables(word))
    .reduce((a, b) => a + b, 0);
}

Problems:

Multiple passes over the same text. Each metric function iterates the entire string independently. For 10,000 words, that's 10,000+ iterations × 20 metrics = 200,000+ iterations per keystroke.
Regex overhead compounds. Sentence splitting with /[.!?]/ and syllable counting with complex regex patterns are expensive. Running them independently on every keystroke creates measurable lag above ~5,000 words.
Edge case failures. split(' ') breaks on multiple spaces, tabs, newlines, and Unicode whitespace. Sentence splitting on /[.!?]/ miscounts abbreviations (U.S.A., Dr., etc.) and decimal numbers (3.14).

Our Approach: Single-Pass Analysis

Instead of running 20 independent functions, we extract all metrics in a single character-by-character pass:

interface TextMetrics {
  words: number;
  characters: number;
  charactersNoSpaces: number;
  sentences: number;
  paragraphs: number;
  syllables: number;
  uniqueWords: number;
  lines: number;
  longestSentence: number;
  shortestSentence: number;
  avgWordLength: number;
  avgSentenceLengthWords: number;
  avgSentenceLengthChars: number;
  readingTimeSeconds: number;
  speakingTimeSeconds: number;
  handwritingTimeMinutes: number;
  pages: number;
  readingLevel: string;
  keywordDensity: KeywordEntry[];
}

function analyzeText(text: string): TextMetrics {
  const len = text.length;

  if (len === 0) return EMPTY_METRICS;

  let words = 0;
  let sentences = 0;
  let paragraphs = 1;
  let syllables = 0;
  let characters = len;
  let charactersNoSpaces = 0;
  let lines = 1;

  let inWord = false;
  let currentWordLength = 0;
  let currentSentenceWords = 0;
  let totalWordLength = 0;
  let longestSentence = 0;
  let shortestSentence = Infinity;

  const wordFrequency = new Map<string, number>();
  let currentWord = '';

  for (let i = 0; i < len; i++) {
    const char = text[i];
    const code = text.charCodeAt(i);

    // Character classification (single check, multiple uses)
    const isWhitespace = code === 32 || code === 9 || code === 160; // space, tab, nbsp
    const isNewline = code === 10 || code === 13;
    const isSentenceEnd = code === 46 || code === 33 || code === 63; // . ! ?

    // Characters without spaces
    if (!isWhitespace && !isNewline) {
      charactersNoSpaces++;
    }

    // Word boundary detection
    if (isWhitespace || isNewline) {
      if (inWord) {
        // Word just ended
        words++;
        currentSentenceWords++;
        totalWordLength += currentWordLength;

        // Keyword tracking
        const lower = currentWord.toLowerCase();
        wordFrequency.set(lower, (wordFrequency.get(lower) || 0) + 1);

        // Syllable counting for the completed word
        syllables += estimateSyllables(currentWord);

        currentWord = '';
        currentWordLength = 0;
        inWord = false;
      }
    } else {
      inWord = true;
      currentWord += char;
      currentWordLength++;
    }

    // Sentence boundary (with abbreviation guard)
    if (isSentenceEnd && i + 1 < len) {
      const nextChar = text.charCodeAt(i + 1);
      const isActualEnd = nextChar === 32 || nextChar === 10 || nextChar === 13;

      if (isActualEnd && currentSentenceWords > 0) {
        sentences++;
        if (currentSentenceWords > longestSentence) longestSentence = currentSentenceWords;
        if (currentSentenceWords < shortestSentence) shortestSentence = currentSentenceWords;
        currentSentenceWords = 0;
      }
    }

    // Line and paragraph counting
    if (isNewline) {
      lines++;
      // Double newline = new paragraph
      if (i + 1 < len && (text.charCodeAt(i + 1) === 10 || text.charCodeAt(i + 1) === 13)) {
        paragraphs++;
      }
    }
  }

  // Handle last word (no trailing whitespace)
  if (inWord) {
    words++;
    currentSentenceWords++;
    totalWordLength += currentWordLength;
    const lower = currentWord.toLowerCase();
    wordFrequency.set(lower, (wordFrequency.get(lower) || 0) + 1);
    syllables += estimateSyllables(currentWord);
  }

  // Handle last sentence
  if (currentSentenceWords > 0) {
    sentences++;
    if (currentSentenceWords > longestSentence) longestSentence = currentSentenceWords;
    if (currentSentenceWords < shortestSentence) shortestSentence = currentSentenceWords;
  }

  // Derived metrics (O(1) calculations)
  const avgWordLength = words > 0 ? totalWordLength / words : 0;
  const avgSentenceLengthWords = sentences > 0 ? words / sentences : 0;
  const readingTimeSeconds = Math.ceil((words / 238) * 60);
  const speakingTimeSeconds = Math.ceil((words / 183) * 60);
  const handwritingTimeMinutes = Math.ceil(words / 13);
  const pages = Math.ceil(words / 250);

  // Keyword density (sort Map by frequency)
  const keywordDensity = getTopKeywords(wordFrequency, words, 10);

  // Reading level (Flesch-Kincaid)
  const readingLevel = calculateReadingLevel(words, sentences, syllables);

  return {
    words,
    characters,
    charactersNoSpaces,
    sentences,
    paragraphs,
    syllables,
    uniqueWords: wordFrequency.size,
    lines,
    longestSentence,
    shortestSentence: shortestSentence === Infinity ? 0 : shortestSentence,
    avgWordLength: Math.round(avgWordLength * 10) / 10,
    avgSentenceLengthWords: Math.round(avgSentenceLengthWords * 10) / 10,
    avgSentenceLengthChars: 0, // calculated if needed
    readingTimeSeconds,
    speakingTimeSeconds,
    handwritingTimeMinutes,
    pages,
    readingLevel,
    keywordDensity
  };
}

The key insight: one loop, one pass, all metrics. Character classification happens once per character and feeds multiple counters. Word boundaries trigger word-level calculations (syllables, frequency) only when a word completes — not on every character.

Syllable Estimation Without Heavy Regex

Syllable counting is the most expensive per-word operation. Academic implementations use CMU Pronouncing Dictionary lookups or complex NLP models. We use a lightweight heuristic:

function estimateSyllables(word: string): number {
  const w = word.toLowerCase().replace(/[^a-z]/g, '');
  if (w.length <= 2) return 1;

  let count = 0;
  let prevVowel = false;
  const vowels = 'aeiouy';

  for (let i = 0; i < w.length; i++) {
    const isVowel = vowels.includes(w[i]);
    if (isVowel && !prevVowel) count++;
    prevVowel = isVowel;
  }

  // Silent e adjustment
  if (w.endsWith('e') && count > 1) count--;

  // Minimum 1 syllable
  return Math.max(count, 1);
}

This runs in O(n) where n is word length — typically 4-8 characters. No regex, no dictionary lookups, no allocations. Accuracy is ~90% compared to CMU dictionary, which is sufficient for reading level estimation.

Debouncing Strategy

Even with sub-1ms analysis, we debounce the AI-heavy features while keeping basic metrics instant:

// Tier 1: Instant (every keystroke, <1ms)
// Word count, character count, basic stats
const instantMetrics = analyzeText(text);
updateUI(instantMetrics);

// Tier 2: Debounced (150ms after last keystroke)
// Keyword density sorting, reading level
const debouncedAnalysis = debounce(() => {
  const detailed = calculateDetailedMetrics(text);
  updateDetailedUI(detailed);
}, 150);

// Tier 3: Idle callback (when browser is idle)
// Social media limit calculations, page estimation
requestIdleCallback(() => {
  updateSocialLimits(text);
});

This tiered approach means basic metrics update on every keystroke with zero perceived delay, while heavier calculations run during natural typing pauses.

Performance Benchmarks

Tested on a mid-range laptop (Intel i5, 8GB RAM, Chrome 120):

Text Size	Analysis Time	FPS During Typing
100 words	0.02ms	60fps
1,000 words	0.08ms	60fps
5,000 words	0.31ms	60fps
10,000 words	0.58ms	60fps
25,000 words	1.4ms	60fps
50,000 words	2.8ms	59fps

Even at 50,000 words — longer than most novels' chapters — the analysis completes well within a single frame budget (16ms). No Web Workers needed, no virtualization, no tricks.

Memory Efficiency

The Map<string, number> for word frequency is the largest allocation. For a 10,000-word text with ~2,000 unique words, this consumes approximately 100KB. We clear it on each analysis pass rather than maintaining a persistent data structure, trading a small amount of GC pressure for simpler code and guaranteed memory bounds.

// No persistent state between analyses
// Each call to analyzeText creates a fresh Map
// GC reclaims the previous Map naturally

Key Takeaways

Single-pass beats multiple specialized functions. One loop extracting 20 metrics is faster than 20 functions each running their own loop.
Character-by-character beats regex for streaming analysis. Regex creates intermediate strings and backtracking. A charCode comparison is a single CPU instruction.
Tiered debouncing preserves perceived performance. Users need word count instantly. They can wait 150ms for keyword density.
Heuristic syllable counting is good enough. 90% accuracy at 100x the speed of dictionary lookup is the right tradeoff for real-time analysis.
Measure before optimizing. Our first version used split/filter/map chains and was fine up to 2,000 words. We only rewrote when users reported lag on longer documents.

Links:

🌐 TextWordCount
🔧 All Tools
📚 Blog
🛒 Store
💼 LinkedIn
📘 Facebook
📺 YouTube
📊 Crunchbase
✍️ Medium

İsmail Günaydın — Founder of TextWordCount. Full-stack web engineer building privacy-first writing tools. LinkedIn · Portfolio

How We Use the Web Crypto API to Build a Truly Fair Random Name Picker Wheel

İsmail Günaydın — Wed, 15 Apr 2026 16:13:19 +0000

Most "random" wheel spinners online aren't really random. They use Math.random(), which is a pseudorandom number generator — predictable, seedable, and manipulable. For a toy, that's fine. For picking a giveaway winner in front of 10,000 viewers, or selecting which student answers a question in a classroom of 30, it's not.

At WheelieNames, we use the Web Crypto API for every spin. Here's why that matters and how we implemented it.

The Problem with Math.random()

JavaScript's Math.random() is a PRNG (Pseudorandom Number Generator). It generates numbers that appear random but are determined by an internal state. In many engines, if you know the state, you can predict every future value.

// This is NOT secure randomness
const winner = Math.floor(Math.random() * names.length);
// Predictable. Seedable. Manipulable.

For most web applications, this is perfectly adequate. For a random selection tool where fairness is the entire point — where teachers, event hosts, and teams need to trust the result — it's insufficient.

Enter the Web Crypto API

The Web Crypto API provides crypto.getRandomValues(), which generates cryptographically strong random values. The W3C specification states that implementations must use a source of entropy suitable for cryptographic operations.

This is the same API used by:

HTTPS/TLS connections
Banking applications
Password generators
UUID generation
Cryptocurrency wallets

If it's secure enough for your bank, it's secure enough for a classroom raffle.

Our Implementation

Here's a simplified version of how WheelieNames generates a fair random selection:

// Cryptographically secure random index selection
function getSecureRandomIndex(max: number): number {
  // Create a typed array for the random value
  const array = new Uint32Array(1);

  // Fill with cryptographically secure random value
  crypto.getRandomValues(array);

  // Convert to index within our range
  // Using modulo with rejection sampling for uniform distribution
  const randomValue = array[0];
  return randomValue % max;
}

// Usage in the wheel
function spinWheel(entries: string[]): string {
  const winnerIndex = getSecureRandomIndex(entries.length);
  return entries[winnerIndex];
}

But there's a subtle issue with the naive modulo approach: if max doesn't evenly divide 2^32, some indices have a slightly higher probability. For true uniformity, we use rejection sampling:

function getUniformRandomIndex(max: number): number {
  const limit = Math.floor(0xFFFFFFFF / max) * max;
  let value: number;

  do {
    const array = new Uint32Array(1);
    crypto.getRandomValues(array);
    value = array[0];
  } while (value >= limit); // Reject values that cause bias

  return value % max;
}

This guarantees every entry has exactly equal probability — not approximately equal, not "close enough," but mathematically equal.

The Animation-Outcome Unity Problem

Here's where most wheel spinners cheat, even unintentionally: they determine the winner with one piece of code, then run a separate animation that lands on that winner. The animation is theater — it has nothing to do with the selection.

This creates a trust problem. If the animation and the outcome are separate systems, there's an invisible layer where manipulation could happen. Even if the developer has no intention of cheating, the architecture allows cheating, and a skeptical audience has no way to verify.

WheelieNames solves this differently:

interface SpinResult {
  winnerIndex: number;
  totalRotation: number;  // degrees
  duration: number;       // milliseconds
}

function calculateSpin(entries: string[]): SpinResult {
  const winnerIndex = getUniformRandomIndex(entries.length);

  // Calculate the angle that lands on this winner
  const segmentAngle = 360 / entries.length;
  const winnerAngle = segmentAngle * winnerIndex;

  // Add random offset within the winning segment
  const offsetArray = new Uint32Array(1);
  crypto.getRandomValues(offsetArray);
  const segmentOffset = (offsetArray[0] / 0xFFFFFFFF) * segmentAngle * 0.8;

  // Total rotation: multiple full spins + landing angle
  const fullSpins = 5 + Math.floor((offsetArray[0] % 5));
  const totalRotation = (fullSpins * 360) + winnerAngle + segmentOffset;

  return {
    winnerIndex,
    totalRotation,
    duration: 3000 + (fullSpins * 200)
  };
}

The key insight: the totalRotation value is derived directly from winnerIndex, which is derived from the cryptographic random value. The animation rotates the wheel by exactly totalRotation degrees using CSS transforms. When the wheel stops, it's pointing at the winner — because the rotation angle was calculated to land there.

One random value → one winner → one rotation angle → one animation. No separate systems. No hidden layer.

Physics-Based Deceleration

A wheel that stops abruptly looks fake. We use an easing function that mimics real physics:

// CSS animation with cubic-bezier easing
function applySpinAnimation(
  wheelElement: HTMLElement, 
  totalRotation: number, 
  duration: number
) {
  wheelElement.style.transition = `transform ${duration}ms cubic-bezier(0.17, 0.67, 0.12, 0.99)`;
  wheelElement.style.transform = `rotate(${totalRotation}deg)`;
}

The cubic-bezier(0.17, 0.67, 0.12, 0.99) curve produces:

Fast initial acceleration
Gradual, realistic deceleration
A satisfying "almost stopped, still creeping" moment near the end
Natural final stop without bounce

This builds genuine suspense. The audience leans in during the deceleration, watches it slow down, and experiences the reveal naturally — just like a physical wheel.

Local-First Data Architecture

Privacy isn't a feature we bolt on. It's a structural decision that eliminates entire categories of problems:

// All data operations use localStorage only
const STORAGE_KEY = 'wheelienames_wheels';

function saveWheel(wheel: WheelConfig): void {
  const wheels = getWheels();
  wheels[wheel.id] = wheel;
  localStorage.setItem(STORAGE_KEY, JSON.stringify(wheels));
  // Nothing leaves the browser. Ever.
}

function getWheels(): Record<string, WheelConfig> {
  const data = localStorage.getItem(STORAGE_KEY);
  return data ? JSON.parse(data) : {};
}

Benefits of this approach:

No server costs for user data storage
No data breaches — we can't leak data we don't have
No GDPR headaches — no personal data processing to declare
Instant performance — no network requests for data operations
Offline capability — the wheel works without internet after initial load

Mobile Touch Implementation

63% of traffic is mobile, and touch interaction needs special attention for a spinning wheel:

// Touch-to-spin with velocity detection
let touchStartAngle = 0;
let touchStartTime = 0;

wheelElement.addEventListener('touchstart', (e) => {
  const touch = e.touches[0];
  touchStartAngle = getAngleFromCenter(touch.clientX, touch.clientY);
  touchStartTime = Date.now();
});

wheelElement.addEventListener('touchend', (e) => {
  const touch = e.changedTouches[0];
  const endAngle = getAngleFromCenter(touch.clientX, touch.clientY);
  const elapsed = Date.now() - touchStartTime;

  // Only trigger spin if swipe was fast enough
  if (elapsed < 300 && Math.abs(endAngle - touchStartAngle) > 10) {
    triggerSpin(); // Uses crypto random, not swipe velocity
  }
});

Important: the touch gesture triggers the spin, but the winner is always determined by the crypto random function — never by swipe speed or direction. The gesture is purely an input trigger.

Results

Since launch:

10M+ spins completed
500K+ monthly users
50K+ teachers using it in classrooms
Zero data breaches (can't breach what you don't store)
Zero "rigged" complaints that survived scrutiny

Try It

Open WheelieNames, add some names, and spin. Then open DevTools → Network tab and verify: zero POST requests. Open Console and run crypto.getRandomValues(new Uint32Array(1)) — that's the same API powering every spin.

Links:

🌐 WheelieNames
📚 Blog & Guides
🛒 App Store
❓ FAQ
📂 GitHub
🚀 Product Hunt
📊 Crunchbase
✍️ Medium
📺 YouTube

İsmail Günaydın — Founder of WheelieNames. Full-stack web engineer, 15+ years of experience. Building privacy-first tools for education and live events. LinkedIn · Portfolio

Building a Privacy-First Health Calculator Platform with Next.js 15 and TypeScript

İsmail Günaydın — Wed, 15 Apr 2026 13:11:49 +0000

I built a health calculator platform used by 10,000+ people monthly across 150+ countries — and it stores exactly zero bytes of user data. Here's how.

The Motivation

Every health calculator I found online had the same problems: they required email signups to see results, stored health data on unknown servers, used unnamed formulas of questionable accuracy, and buried the actual answer under supplement ads.

I wanted to build the opposite: a platform where you get an accurate, clinician-reviewed result in 30 seconds with zero friction and zero data collection. That's HealthCalcPro.

The Tech Stack

Framework: Next.js 15 (App Router + Server Components)
Language: TypeScript (strict mode)
Styling: Tailwind CSS
Database: Supabase (PostgreSQL)
Deployment: Vercel (Edge Network)
CDN: Cloudflare
Performance: 100/100 PageSpeed target
Accessibility: WCAG 2.2 compliant

Architecture Decisions

1. Client-Side Only Computation

This was the foundational decision. Every health calculation runs entirely in the browser using TypeScript functions. No form data is ever POSTed to a server.

// Example: Mifflin-St Jeor BMR calculation
// Source: Mifflin MD et al. (1990) - Am J Clin Nutr

interface UserMetrics {
  weight: number;    // kg
  height: number;    // cm
  age: number;       // years
  sex: 'male' | 'female';
}

function calculateBMR(metrics: UserMetrics): number {
  const { weight, height, age, sex } = metrics;

  const base = (10 * weight) + (6.25 * height) - (5 * age);

  return sex === 'male' 
    ? base + 5 
    : base - 161;
}

function calculateTDEE(bmr: number, activityLevel: number): number {
  // Activity multipliers from ACSM guidelines
  // Sedentary: 1.2 | Light: 1.375 | Moderate: 1.55
  // Active: 1.725 | Very Active: 1.9
  return Math.round(bmr * activityLevel);
}

The benefit: I can truthfully tell users that nothing they enter ever leaves their device. Open the Network tab — you'll see zero POST requests during any calculation.

2. Named Formulas with Unit Tests

Every calculator maps directly to a published, peer-reviewed formula:

Calculator	Formula	Source
BMI	Weight / Height²	WHO Standards
BMR/TDEE	Mifflin-St Jeor	Am J Clin Nutr, 1990
Body Fat	Navy Method	U.S. Navy / Jackson-Pollock
Ideal Weight	Devine, Robinson, Miller, Hamwi	Multiple clinical papers
Heart Rate Zones	Karvonen Method	ACSM Guidelines
Blood Pressure	Category Classification	AHA / CDC

Each formula has unit tests that validate against published examples:

// Unit test: Mifflin-St Jeor validation
// Published example: 70kg male, 175cm, 30 years = BMR ~1,698

describe('calculateBMR', () => {
  it('matches published Mifflin-St Jeor example for males', () => {
    const result = calculateBMR({
      weight: 70,
      height: 175,
      age: 30,
      sex: 'male'
    });
    expect(result).toBeCloseTo(1698, 0);
  });

  it('matches published example for females', () => {
    const result = calculateBMR({
      weight: 60,
      height: 165,
      age: 25,
      sex: 'female'
    });
    expect(result).toBeCloseTo(1370, 0);
  });

  it('handles edge case: very low BMI', () => {
    const result = calculateBMR({
      weight: 40,
      height: 150,
      age: 18,
      sex: 'female'
    });
    expect(result).toBeGreaterThan(0);
    expect(result).toBeLessThan(2000);
  });
});

3. Mobile-First Responsive Design

63% of our traffic comes from mobile. Every calculator is designed mobile-first with Tailwind CSS:

// Responsive calculator card grid
<div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
  {calculators.map((calc) => (
    <CalculatorCard
      key={calc.slug}
      title={calc.title}
      description={calc.description}
      category={calc.category}
      href={`/calculators/${calc.slug}`}
    />
  ))}
</div>

Input forms use large touch targets, clear labels, and instant visual feedback — because fumbling with tiny number inputs on a phone while trying to check your calorie needs is a terrible experience.

4. Server Components for Performance

Next.js 15's App Router lets us split the application into server and client components strategically:

Server Components (no JS shipped to client):
├── Layout, navigation, footer
├── Calculator page shells
├── Health guide articles
├── SEO metadata generation
└── Static content rendering
Client Components (interactive):
├── Calculator input forms
├── Result displays with animations
├── Health Dashboard charts
├── Health Age Quiz flow
└── Unit conversion toggles

This means the initial page load is extremely fast — only the interactive calculator form ships JavaScript to the client. The surrounding content renders on the server.

5. Schema.org Structured Data

Every calculator page includes comprehensive JSON-LD markup for both traditional search engines and AI search engines:

{
  "@context": "https://schema.org",
  "@type": "WebApplication",
  "name": "BMI Calculator",
  "description": "Free clinician-reviewed BMI calculator...",
  "applicationCategory": "HealthApplication",
  "operatingSystem": "Any (web browser)",
  "offers": {
    "@type": "Offer",
    "price": "0",
    "priceCurrency": "USD"
  },
  "author": {
    "@type": "Organization",
    "name": "HealthCalcPro",
    "url": "https://www.healthcalcpro.com"
  }
}

Plus FAQPage schema on every calculator for featured snippet targeting:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "How do I calculate my BMI?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "BMI is calculated by dividing weight (kg) by height (m) squared..."
    }
  }]
}

The Results

Six months after launch:

10,000+ monthly users across 150+ countries
500,000+ calculations performed
4.9/5 average rating from user feedback
100/100 PageSpeed on most calculator pages
Zero data breaches (hard to breach data you don't collect)

Advanced Features

Beyond the core calculators:

Health Age Quiz — A 12-question assessment built as a multi-step React form that estimates biological age based on lifestyle factors. Uses a scoring algorithm weighted by published longevity research.

Personal Health Dashboard — Stores results in the browser's local state (never on our servers) and displays trend charts using Recharts. Users can track BMI, calories, body fat, and other metrics over time.

AI Workout Builder — Generates personalized exercise plans using AI based on fitness level, available equipment, and goals.

AI Store — 19+ premium products including Claude Code skills, AI agents, and automation tools that fund the ongoing development of the free calculators.

What I Learned

Privacy as a feature, not a constraint. Not collecting data isn't just ethical — it simplifies architecture, eliminates compliance headaches (GDPR, HIPAA), and builds trust that converts to word-of-mouth growth.

Named formulas build credibility. Linking to the actual PubMed paper behind each calculation transforms "some random online calculator" into "a tool I trust enough to recommend to my patients." Several healthcare professionals have told us exactly this.

Mobile-first is non-negotiable for health tools. People check their BMI or calorie needs on their phone, usually right after a doctor's appointment or during meal prep. If the experience is bad on mobile, they leave.

Plain-English matters more than precision. A result of "Your BMI is 24.8, which falls in the normal weight range according to WHO standards" is infinitely more useful than just "24.8" — even though the math is identical.

Try It

If you're a developer who's built health or fitness tools, I'd love to hear your approach. And if you're someone who's been frustrated by the state of online health calculators, give HealthCalcPro a try:

🌐 Website: healthcalcpro.com
🧬 Health Age Quiz: healthcalcpro.com/health-age-quiz
📊 Dashboard: healthcalcpro.com/dashboard
🏋️ AI Workout: healthcalcpro.com/workout
🛒 AI Store: healthcalcpro.com/ai-store/en
📚 Health Guides: healthcalcpro.com/guides
📂 GitHub: github.com/ismailGunaydn/HealthCalcPro
🗂 Wikidata: Q135988866
💼 LinkedIn: linkedin.com/company/healthcalcpro
✍️ Medium: Why We Built HealthCalcPro
📊 Crunchbase: crunchbase.com/organization/healthcalcpro

İsmail Günaydın — Founder of HealthCalcPro. Full-stack web engineer with 15+ years of experience. I build privacy-first web applications and operate a network of 16 digital brands. LinkedIn · Portfolio

Why Your Website Is Invisible to AI Search Engines (And How to Fix It)

İsmail Günaydın — Sun, 05 Apr 2026 14:03:12 +0000

Google is no longer the only search engine that matters.

Every day, millions of users ask ChatGPT, Perplexity, Claude, and Gemini for recommendations:

"Best dentist in Istanbul for veneers"
"Top web design agencies for startups"
"Find me an immigration lawyer in London"

If your website doesn't appear in those AI-generated answers, you're losing customers to competitors who do. And here's the uncomfortable truth: traditional SEO alone won't get you there.

At ModernWebSEO, we've developed a three-layer approach that tackles this exact problem.

The Three Layers

Layer 1 — SEO: Still the Foundation

Google organic search isn't dead — far from it. But the bar is higher than ever:

Core Web Vitals must be green across all metrics
Mobile-first indexing means your desktop site is irrelevant if mobile is broken
E-E-A-T signals (Experience, Expertise, Authoritativeness, Trustworthiness) directly impact rankings
Page speed matters more than ever — 53% of visitors leave if loading takes more than 3 seconds

We build on Next.js 15 with server-side rendering, automatic code splitting, and edge deployment on Vercel. Every site targets 100/100 on PageSpeed Insights. No WordPress, no templates — every line of code is custom.

// Our typical tech stack
const stack = {
  framework: "Next.js 15 (App Router)",
  language: "TypeScript",
  styling: "Tailwind CSS",
  database: "Supabase (PostgreSQL)",
  deployment: "Vercel (Edge Network)",
  cdn: "Cloudflare",
  analytics: "Google Analytics 4 + Search Console"
};

Layer 2 — AEO: Be the Direct Answer

Answer Engine Optimization is about becoming the source that search engines — both traditional and AI-powered — pull answers from.

When someone asks "What is the best treatment for hair loss?" and Google shows a Featured Snippet, that's AEO at work. When Siri or Alexa answers a voice query, they're pulling from AEO-optimized content.

Key tactics:

FAQ Schema markup on every relevant page
Q&A content structures that match natural language queries
People Also Ask optimization
Conversational keyword research targeting how people actually talk
Structured data (JSON-LD) that machines can parse instantly

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "What is Answer Engine Optimization?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "AEO is the practice of optimizing content to appear as direct answers in search engines, voice assistants, and AI-powered search tools."
    }
  }]
}

Layer 3 — GEO: Get Cited by AI

Generative Engine Optimization is the newest and most important layer. This is what makes ChatGPT, Perplexity, Claude, or Gemini cite your brand when users ask for recommendations.

AI models decide which sources to cite based on:

Entity Authority — Does your brand exist as a recognized entity across the web? Wikipedia, Wikidata, Crunchbase, LinkedIn, GitHub — these all contribute to entity recognition.
E-E-A-T Signals — Is there evidence that real humans with real expertise are behind the content? Author bios, professional credentials, published research, and media mentions all matter.
Structured Data Consistency — Is your business information (name, address, phone, services) consistent across every platform? Inconsistencies confuse AI models.
Content Depth & Originality — AI models favor comprehensive, original content over thin pages stuffed with keywords. They can detect regurgitated content.
Citation Network — Are authoritative sources linking to and mentioning your brand? This creates a web of trust that AI models rely on.

The Entity Stack Approach

One of the most powerful GEO techniques is building what we call an Entity Stack — a comprehensive network of profiles and content across high-authority platforms that establishes your brand as a recognized entity.

Here's a simplified version of our entity stack framework:

Platform	Domain Rating	Purpose
GitHub	DR 96	Technical authority, open-source presence
LinkedIn	DR 98	Professional credibility, company page
Crunchbase	DR 91	Business entity recognition
Medium	DR 94	Thought leadership content
Behance	DR 92	Portfolio and design showcase
Dev.to	DR 90	Developer community presence
YouTube	DR 99	Video content, tutorials
Wikidata	DR 94	Structured entity data

Each platform profile links back to your main website, contains consistent business information, and reinforces your brand's expertise in specific topics. This creates a dense entity graph that AI models can traverse and trust.

Real-World Implementation

At ModernWebSEO, we implement this strategy for businesses across multiple sectors:

Health Tourism Clinics — Multilingual patient acquisition systems optimized for both Google and AI search in Turkish, English, Arabic, and Spanish
Law Firms — Authority-building content strategies that get cited in AI legal research
E-Commerce — Product pages with rich structured data that appear in AI shopping recommendations
Professional Services — Personal brand building for architects, consultants, and designers

Our Venture Builder Model

We don't charge large upfront fees and disappear. Under our Venture Builder / Technical Co-founder model:

We build the entire digital infrastructure at our own cost
We run aggressive SEO + AEO + GEO optimization for 6 months
We manage digital marketing, CRM, and lead generation
We share in the profits when results come

Zero startup risk for the client. We're that confident in our system.

Getting Started

If you want to check how visible your business currently is in AI search engines, try this:

Open ChatGPT, Perplexity, or Gemini
Ask: "Recommend a [your industry] in [your city]"
See if your business appears

If it doesn't, that's the gap we fill.

Links:

🌐 ModernWebSEO
🌐 English Version
💼 LinkedIn
📂 GitHub
🎨 Behance
📊 Crunchbase

I'm İsmail Günaydın, founder of ModernWebSEO — a software engineer and venture builder based in Istanbul. I help businesses become visible in both Google and AI search engines. Connect with me on LinkedIn or X/Twitter.