Image Format Comparison

FormatCompressionTransparencyAnimationBrowser SupportFile Size vs PNGJPEGLossy❌❌100%50–70% smallerPNGLossless✅❌100%BaselineWebPLossy + Lossless✅✅97%25–35% smallerAVIFLossy + Lossless✅✅93%50–60% smallerJPEG XLLossy + Lossless✅❌Growing40–50% smaller

Recommendation in 2026: Serve AVIF as the primary format with WebP fallback. Most modern browsers (93%) support AVIF, and WebP covers the remaining.

Generating Optimized Images

Automated Build Pipeline

// scripts/optimize-images.ts
// Run during build process
import sharp from "sharp"
import { readdir, readFile, writeFile } from "fs/promises"
import path from "path"

interface ImageConfig {
  source: string       // Original image path
  outputDir: string    // Base output directory
  formats: string[]    // ['avif', 'webp', 'jpeg']
  sizes: number[]      // [640, 1200, 1920]
  quality: number      // 80
}

async function optimizeImage(config: ImageConfig) {
  const inputBuffer = await readFile(config.source)
  const filename = path.parse(config.source).name

  for (const format of config.formats) {
    for (const width of config.sizes) {
      const outputPath = path.join(
        config.outputDir,
        format,
        `${filename}-${width}w.${format}`
      )

      await sharp(inputBuffer)
        .resize(width, undefined, { withoutEnlargement: true })
        .toFormat(format as any, { quality: config.quality })
        .toFile(outputPath)

      console.log(`Created: ${outputPath}`)
    }
  }
}

Responsive Images with srcset

// components/OptimizedImage.tsx
interface OptimizedImageProps {
  src: string  // e.g., "/images/dashboard"
  alt: string
  widths?: number[]
  sizes?: string
  priority?: boolean
}

function OptimizedImage({
  src,
  alt,
  widths = [640, 1200, 1920],
  sizes = "(max-width: 768px) 100vw, (max-width: 1200px) 50vw, 33vw",
  priority = false,
}: OptimizedImageProps) {
  const formats = ["avif", "webp", "jpeg"]
  const suffix = priority ? "fetchPriority='high'" : "loading='lazy'"

  return (
    <picture>
      {/* Modern format first */}
      {formats.map((format) => (
        <source
          key={format}
          type={`image/${format === "jpeg" ? "jpeg" : format}`}
          srcSet={widths
            .map((w) => `${src}-${w}w.${format} ${w}w`)
            .join(", ")
          }
          sizes={sizes}
        />
      ))}
      {/* Fallback */}
      <img
        src={`${src}-1200w.jpeg`}
        srcSet={widths
          .map((w) => `${src}-${w}w.jpeg ${w}w`)
          .join(", ")
        }
        alt={alt}
        width={1200}
        height={675}
        decoding="async"
        {...(priority ? { fetchPriority: "high" as const } : { loading: "lazy" as const })}
      />
    </picture>
  )
}

CDN-Based Image Optimization

Using Cloudflare Image Resizing eliminates the need for build-time generation:

// Skip build-time optimization — transform on the fly
function CdnImage({ src, width, alt, priority = false }: CdnImageProps) {
  const baseUrl = "https://tanstackship.com/cdn-cgi/image"

  // Generate transform URLs
  const formats = [
    { format: "avif", url: `${baseUrl}/width=${width},format=avif,quality=80/${src}` },
    { format: "webp", url: `${baseUrl}/width=${width},format=webp,quality=80/${src}` },
    { format: "jpeg", url: `${baseUrl}/width=${width},format=jpeg,quality=85/${src}` },
  ]

  return (
    <picture>
      {formats.map(({ format, url }) => (
        <source key={format} type={`image/${format}`} srcSet={url} />
      ))}
      <img
        src={`${baseUrl}/width=${width},format=jpeg,quality=85/${src}`}
        alt={alt}
        width={width}
        loading={priority ? "eager" : "lazy"}
        fetchPriority={priority ? "high" : "auto"}
      />
    </picture>
  )
}

Image Resizing Options

// Available CDN parameters — build helper
interface ImageTransformOptions {
  width?: number       // 1-4096
  height?: number      // 1-4096
  fit?: "scale-down" | "contain" | "cover" | "crop" | "pad"
  quality?: number     // 1-100
  format?: "webp" | "avif" | "jpeg" | "png"
  sharpen?: number     // 0-10
  blur?: number        // 0-250
  brightness?: number  // -100 to 100
  contrast?: number    // -100 to 100
  gamma?: number       // 0.1-9.99
}

function buildImageUrl(basePath: string, opts: ImageTransformOptions): string {
  const params = Object.entries(opts)
    .filter(([, v]) => v !== undefined)
    .map(([k, v]) => `${k}=${v}`)
    .join(",")

  return `/cdn-cgi/image/${params}/${basePath}`
}

Lazy Loading Strategy

// Intelligent lazy loading based on viewport position
function LazyImage({ src, alt, threshold = 0.1 }: LazyImageProps) {
  const imgRef = useRef<HTMLImageElement>(null)
  const [loaded, setLoaded] = useState(false)
  const [inView, setInView] = useState(false)

  useEffect(() => {
    const observer = new IntersectionObserver(
      ([entry]) => {
        if (entry.isIntersecting) {
          setInView(true)
          observer.disconnect()
        }
      },
      { rootMargin: "200px", threshold }
    )

    if (imgRef.current) observer.observe(imgRef.current)
    return () => observer.disconnect()
  }, [threshold])

  return (
    <div ref={imgRef} className="image-wrapper" style={{ minHeight: "200px" }}>
      {inView ? (
        <img
          src={src}
          alt={alt}
          onLoad={() => setLoaded(true)}
          className={loaded ? "loaded" : "loading"}
          loading="lazy"
        />
      ) : (
        <div className="image-skeleton" />
      )}
    </div>
  )
}

Lazy Loading MethodProsConsNative loading="lazy"Zero JS, browser-nativeLess control over thresholdIntersection ObserverPrecise controlRequires JSBelow-fold onlySimpleManual per-imagePriority hintsWorks with native lazyLimited browser support

Automated Image Pipeline

// server/images/pipeline.ts
export const uploadImage = createServerFn({ method: "POST" }).handler(
  async ({ request, context }) => {
    const formData = await request.formData()
    const file = formData.get("image") as File

    // Validation
    if (!file.type.startsWith("image/")) throw new Error("Invalid file type")
    if (file.size > 10 * 1024 * 1024) throw new Error("File too large")

    const buffer = await file.arrayBuffer()
    const id = crypto.randomUUID()
    const key = `images/${id}`

    // Store original
    await context.env.MY_BUCKET.put(`${key}/original`, buffer, {
      httpMetadata: { contentType: file.type },
    })

    // Generate thumbnails via Image Resizing
    const sizes = [
      { width: 150, suffix: "thumb" },
      { width: 400, suffix: "small" },
      { width: 800, suffix: "medium" },
      { width: 1600, suffix: "large" },
    ]

    for (const { width, suffix } of sizes) {
      // Store reference — actual resize happens on CDN
      await context.env.MY_BUCKET.put(`${key}/${suffix}.webp`, buffer)
    }

    return {
      id,
      urls: {
        original: `https://images.tanstackship.com/${key}/original`,
        thumb: `https://images.tanstackship.com/cdn-cgi/image/width=150/${key}/original`,
        small: `https://images.tanstackship.com/cdn-cgi/image/width=400/${key}/original`,
        medium: `https://images.tanstackship.com/cdn-cgi/image/width=800/${key}/original`,
        large: `https://images.tanstackship.com/cdn-cgi/image/width=1600/${key}/original`,
      },
    }
  }
)

Performance Impact

Image TypeBeforeAfter (AVIF + Responsive)SavingsHero image (1920px)1.2 MB (JPEG)180 KB (AVIF)85%Blog thumbnail (400px)180 KB (JPEG)35 KB (AVIF)81%Product screenshot (1200px)850 KB (PNG)120 KB (WebP)86%Icon set (32px SVG)25 KB25 KB (already optimized) — Total page weight2.5 MB380 KB85% reduction

Image CDN Cost Comparison

ProviderBandwidthTransformationsStorageCloudflare ImagesIncluded with Workers$0.50/1000 unique$5/1000 imagesCloudflare Image ResizingFree with Pro Bizper-requestN/A (via R2)imgix$0.10/GBIncluded$0.20/GBCloudinaryFree tier: 25GB CDN25GB transformations25GB storageAWS CloudFront + Lambda@Edge$0.085/GBLambda costS3 pricing

Image Optimization Checklist

• [ ] AVIF used as primary format, WebP as fallback
• [ ] Responsive images with srcset and sizes attributes
• [ ] Lazy loading for all images below the fold
• [ ] Explicit width and height to prevent CLS
• [ ] CDN-based image transformation for dynamic sizing
• [ ] Automated build pipeline for static images
• [ ] Image quality set to 80–85 (diminishing returns after this)
• [ ] SVG used for icons and illustrations where possible
• [ ] Preload LCP images with fetchpriority=”high”
• [ ] Monitor Lighthouse image optimization score weekly

Conclusion

Image optimization is not optional — it is the single highest-impact performance optimization for most web pages. The modern approach combines three strategies:

1. Format selection: AVIF for quality, WebP for compatibility
2. Responsive delivery: Different sizes for different viewports
3. CDN optimization: Transform on the edge, cache at the edge

With Cloudflare Image Resizing, you can skip the build-time optimization pipeline entirely and let the CDN handle format selection, resizing, and compression dynamically. This simplifies the development workflow while delivering optimal images to every browser.

For a production site with complete image optimization, see tanstackship.com.

Related Resources

• Cloudflare R2: Object Storage for Edge Applications
• Core Web Vitals Optimization Guide
• Edge Caching Strategies: From CDN to Workers Cache
• Lighthouse 95+ Optimization Tips for SaaS

The SaaS Discounting Dilemma

Discount StrategyRiskRewardBest For20–30% off annual plansLow (annual commitment offsets discount)HighBlack Friday, New YearFree monthMedium (user may cancel after)MediumTrial conversion pushLifetime discount (early adopter)High (permanent revenue reduction)Very highLaunch2-for-1 annualMediumHighEnd-of-year pushFirst 3 months 50% offMedium (churn after discount)MediumQ1 slumps

Key principle: Discount annual plans, not monthly. An annual discount locks in revenue for 12 months. A monthly discount creates churn risk when the promotional period ends.

Holiday Calendar by Market

Major SaaS Promotion Windows

HolidayDateMarketSaaS OpportunityNew Year / Q1 PushJan 1–31GlobalAnnual plan adoptionValentine’s DayFeb 14US, EU”Love your business” campaignSpring SaleMarch-AprilGlobalNew year, new stackTax SeasonAprilUSSpending mindsetSummer SlumpJune-AugustGlobal”Get ahead before fall”Back to SchoolSeptUS, EUProductivity pushSingles’ Day (11.11)Nov 11ChinaBiggest shopping day globallyBlack Friday / Cyber MondayNov-DecGlobalThe biggest SaaS promo windowChristmas / Year-EndDec 15–31GlobalLast-chance annual deals

Campaign Structure

Campaign Database Schema

// D1 schema for campaign management
export const campaigns = sqliteTable("campaigns", {
  id: text("id").primaryKey(),
  name: text("name").notNull(),
  slug: text("slug").notNull().unique(),
  type: text("type", {
    enum: ["holiday", "seasonal", "launch", "retention", "reactivation"],
  }).notNull(),
  discountPercent: real("discount_percent").notNull(),
  discountType: text("discount_type", {
    enum: ["percentage", "fixed", "free_month", "tiered"],
  }).notNull(),
  appliesTo: text("applies_to", {
    enum: ["annual", "monthly", "all_plans", "specific_plans"],
  }).notNull(),
  specificPlans: text("specific_plans"), // JSON array of plan IDs
  startDate: integer("start_date", { mode: "timestamp" }).notNull(),
  endDate: integer("end_date", { mode: "timestamp" }).notNull(),
  maxRedemptions: integer("max_redemptions"),
  currentRedemptions: integer("current_redemptions").default(0),
  isActive: integer("is_active", { mode: "boolean" }).default(true),
  couponCode: text("coupon_code"),
  metadata: text("metadata"), // JSON for campaign assets
  createdAt: integer("created_at", { mode: "timestamp" }),
})

Creating a Campaign

// server/campaigns.ts
export const createCampaign = createServerFn({ method: "POST" }).handler(
  async ({ data, context }: { data: CreateCampaignInput }) => {
    const id = crypto.randomUUID()

    // Create Stripe coupon
    const coupon = await stripe.coupons.create({
      percent_off: data.discountPercent,
      duration: "once",
      max_redemptions: data.maxRedemptions,
      applies_to: {
        products: data.specificPlans.length > 0
          ? data.specificPlans
          : undefined,
      },
    })

    await context.env.DB.prepare(`
      INSERT INTO campaigns
        (id, name, slug, type, discount_percent, discount_type,
         applies_to, start_date, end_date, max_redemptions, coupon_code)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    `).bind(
      id, data.name, data.slug, data.type,
      data.discountPercent, data.discountType,
      data.appliesTo, data.startDate.getTime(),
      data.endDate.getTime(), data.maxRedemptions,
      coupon.id
    ).run()

    return { id, couponId: coupon.id }
  }
)

Black Friday Campaign Example

Pre-Launch (2 Weeks Before)

// Prepare campaign assets and notifications
export const prepareCampaign = createServerFn({ method: "GET" }).handler(
  async ({}, { context }) => {
    const upcoming = await context.env.DB.prepare(`
      SELECT * FROM campaigns
      WHERE start_date > ? AND start_date < ?
      AND is_active = 1
    `).bind(Date.now(), Date.now() + 14 * 24 * 60 * 60 * 1000).all()

    for (const campaign of upcoming.results) {
      // Send announcement emails to subscribers
      await sendCampaignAnnouncement(campaign)

      // Update pricing page to show upcoming sale
      // Update in KV for zero-downtime
      await context.env.KV.put("campaign:upcoming", JSON.stringify({
        name: campaign.name,
        discountPercent: campaign.discount_percent,
        startDate: campaign.start_date,
        slug: campaign.slug,
      }))
    }

    return { prepared: true, count: upcoming.results.length }
  }
)

Live Campaign

// Apply discount during checkout
export const applyCampaignDiscount = createServerFn({ method: "POST" }).handler(
  async ({ data, context }: {
    data: { campaignSlug: string; priceId: string }
  }) => {
    const campaign = await context.env.DB.prepare(`
      SELECT * FROM campaigns
      WHERE slug = ? AND is_active = 1
      AND start_date <= ? AND end_date >= ?
    `).bind(data.campaignSlug, Date.now(), Date.now()).first()

    if (!campaign) {
      return { valid: false, error: "Campaign not active" }
    }

    // Check redemption limit
    if (campaign.max_redemptions && campaign.current_redemptions >= campaign.max_redemptions) {
      return { valid: false, error: "Campaign fully redeemed" }
    }

    // Increment counter
    await context.env.DB.prepare(`
      UPDATE campaigns SET current_redemptions = current_redemptions + 1
      WHERE id = ?
    `).bind(campaign.id).run()

    return {
      valid: true,
      couponCode: campaign.coupon_code,
      discountPercent: campaign.discount_percent,
    }
  }
)

Promotion Types: Which to Use

TypeConversion RateRevenue ImpactBest Timing% off annual+30–50%High (annual lock-in)Black Friday, New YearFree months+20–30%MediumLaunch, reactivationTiered discount+25–40%Medium-HighExtended periodsLimited time+40–60%High (urgent)24–48 hour flash salesBOGO (buy org, get 1 free)+15–20%MediumTeam/Org plansBundle discount+20–25%MediumFeature add-ons

Percentage Off vs Free Months

Percentage off annual plan:
  Normal: $29/mo × 12 = $348/year
  With 30% off: $243.60/year (saves $104.40)
  ✅ User commits for 12 months
  ✅ You get cash upfront
  ✅ Lower churn risk

Free months on monthly plan:
  Normal: $29/mo × 12 = $348/year
  With 2 months free: $29/mo × 10 = $290/year (saves $58)
  ❌ User can cancel any time
  ❌ Revenue is deferred
  ❌ Higher churn risk

Winner: Percentage off annual plan

Analytics and Attribution

// Track campaign performance
export const getCampaignAnalytics = createServerFn({ method: "GET" }).handler(
  async ({ data, context }: { data: { campaignId: string } }) => {
    const [campaign, conversions, revenue] = await Promise.all([
      context.env.DB.prepare("SELECT * FROM campaigns WHERE id = ?")
        .bind(data.campaignId).first(),
      context.env.DB.prepare(`
        SELECT COUNT(*) as conversions, SUM(mrr) as total_mrr
        FROM subscriptions
        WHERE coupon_id = (SELECT coupon_code FROM campaigns WHERE id = ?)
        AND created_at BETWEEN
          (SELECT start_date FROM campaigns WHERE id = ?) AND
          (SELECT end_date FROM campaigns WHERE id = ?)
      `).bind(data.campaignId, data.campaignId, data.campaignId).first(),
      context.env.DB.prepare(`
        SELECT SUM(amount) as total_revenue
        FROM invoices
        WHERE subscription_id IN (
          SELECT id FROM subscriptions
          WHERE coupon_id = (SELECT coupon_code FROM campaigns WHERE id = ?)
        )
      `).bind(data.campaignId).first(),
    ])

    return { campaign, conversions, revenue }
  }
)

Anti-Discounting Patterns

BehaviorProblemSolutionAlways running a promotionUsers wait for discountsCreate clear promotion windowsDiscounting monthly plansHigh churn after promotionDiscount annual only50%+ discountsDevalues the productCap at 30–40%No expirationNo urgencyLimited time onlyDiscounting core featuresTrains users to value features lessDiscount commitment, not features

Campaign Calendar Template

Q1 (Jan-Mar): New Year Annual Plan Push
  - "New Year, New Stack" — 25% off annual
  - Target: Free users on monthly, upgrade to annual

Q2 (Apr-Jun): Spring Refresh
  - "Spring Cleaning" — 20% off annual
  - Target: Inactive users reactivation

Q3 (Jul-Sep): Back to Business
  - "Back to School for Your Business" — 20% off team plans
  - Target: Team/org plan upgrades

Q4 (Oct-Dec): Black Friday + Year-End
  - Pre-BF: "Early Black Friday" — 30% off annual (limited quantity)
  - BF/CM: "Black Friday Deal" — 35% off annual
  - Year-End: "Last Chance 2026" — 25% off annual
  - Target: All segments, maximum conversion

Promotion Management Checklist

• [ ] Campaign start/end dates set with proper timezone handling (UTC)
• [ ] Stripe coupon created with redemption limits
• [ ] Pricing page dynamically shows/hides promotional pricing
• [ ] Email sequences ready: announcement, reminder, last chance, expired
• [ ] UTM parameters set for all campaign links
• [ ] Analytics dashboard tracking: impressions, clicks, conversions, revenue
• [ ] Post-campaign retention analysis (do promo users retain at normal rates?)
• [ ] Expired campaigns automatically hidden from checkout
• [ ] Customer support briefed on campaign details
• [ ] Refund policy adjusted for promotional purchases

Conclusion

Holiday promotions are a powerful growth lever for SaaS — when executed strategically. The key principles are:

1. Discount annual plans, not monthly — annual commitment protects your revenue
2. Cap discounts at 30–35% — higher discounts devalue the product
3. Create urgency — limited-time offers convert better than permanent discounts
4. Track everything — UTM, coupon codes, conversion analytics, retention rates
5. Plan a calendar — know your promotion windows months in advance

The campaign management infrastructure — database schema, Stripe integration, analytics tracking — should be built once and reused for every promotion. With the right infrastructure, a holiday campaign is a matter of configuration, not engineering.

For a SaaS with built-in campaign management, UTM tracking, and promotion infrastructure, see tanstackship.com.

Related Resources

• SaaS Growth Framework: First 100 Paying Customers
• Email Marketing Automation: From Signup to Paid
• SaaS Pricing Psychology: Anchoring, Scarcity, Reciprocity
• UTM Attribution Complete Guide