Ad Delivery Overview

Ring DAS Ad Delivery is a high-performance, ML-powered ad serving system designed for retail media networks, publishers, and digital platforms. The Ad Delivery Engine (also known as the Bidder) handles billions of ad requests daily, making real-time decisions about which ads to serve based on targeting criteria, campaign budgets, and optimization goals.

What is Ad Delivery?

Ad Delivery encompasses the entire lifecycle of serving an advertisement to a user, from receiving an ad request to rendering the creative and tracking user interactions. Ring DAS Ad Delivery provides:

Real-time ad decisioning with sub-100ms response times
ML-based optimization for campaign performance
Flexible integration options (client-side SDK, server-side API, Prebid.js)
Advanced targeting using audiences, key-values, and contextual signals
Budget management with real-time pacing and frequency capping
Multi-format support for display, native, video, and rich media ads

Architecture Overview

Ring DAS Ad Delivery is built on a distributed, event-driven architecture designed for high availability and low latency.

graph TB
    subgraph "Client Layer"
        WEB[Web Browser]
        APP[Mobile App]
        SERVER[Server-Side]
    end

    subgraph "Integration Layer"
        SDK[DL API SDK]
        PREBID[Prebid.js Adapter]
        API[HTTP API]
    end

    subgraph "Ad Delivery Engine"
        ROUTER[Request Router]
        BIDDER[Ad Decision Engine<br/>Bidder]
        CREATIVE[Creative Selector]
        RENDER[Rendering Engine]
    end

    subgraph "Data & Decisioning"
        INVENTORY[Inventory Manager]
        AUDIENCE[Audience DB]
        CAMPAIGN[Campaign Data]
        ML[ML Models<br/>Smart Deals]
    end

    subgraph "Tracking & Analytics"
        PIXEL[DAS Pixel]
        EVENTS[Event Collector]
        REPORTS[Reporting System]
    end

    WEB --> SDK
    APP --> SDK
    SERVER --> API
    WEB --> PREBID

    SDK --> ROUTER
    PREBID --> ROUTER
    API --> ROUTER

    ROUTER --> BIDDER
    BIDDER --> CREATIVE
    CREATIVE --> RENDER

    BIDDER <--> INVENTORY
    BIDDER <--> AUDIENCE
    BIDDER <--> CAMPAIGN
    BIDDER <--> ML

    RENDER --> WEB
    RENDER --> APP
    RENDER --> SERVER

    WEB --> PIXEL
    APP --> PIXEL
    PIXEL --> EVENTS
    EVENTS --> REPORTS

Core Components

1. Ad Decision Engine (Bidder)

The Bidder is the brain of Ring DAS Ad Delivery. It processes ad requests and selects the optimal creative to serve based on:

Targeting criteria: Geography, device, audience segments, key-value pairs
Campaign eligibility: Budget availability, flight dates, frequency caps
Optimization goals: CTR, conversions, viewability, revenue
Auction mechanics: Priority-based or real-time bidding (RTB)

The Bidder uses machine learning models to predict campaign performance and optimize ad selection in real-time.

2. Creative Selector & Rendering Engine

Once the Bidder selects a winning Line Item, the Creative Selector chooses the most appropriate Creative based on:

Ad unit size and format requirements
Device capabilities (mobile, desktop, tablet)
Creative performance history
A/B testing configurations

The Rendering Engine generates the final ad markup (HTML, JavaScript, VAST) and delivers it to the client.

3. Inventory Manager

The Inventory Manager defines where ads can be served. It manages:

Ad Units: Named placements on websites or apps
Placements: Logical groupings of ad units
Key-Value Targeting: Custom targeting parameters (e.g., category=sports, section=homepage)
Floor Prices: Minimum CPM for programmatic demand
Scripts & Tags: Custom JavaScript for ad delivery

4. Campaign Data Store

Campaign data includes the hierarchy of Deal → Line Item → Creative:

Deals: Commercial agreements with advertisers
Line Items: Individual campaigns with targeting, budgets, and KPIs
Creatives: Ad assets (images, videos, HTML5)

This data is cached and updated in real-time to ensure the Bidder always has the latest campaign state.

5. Audience Database

The Audience database stores user segments created from:

DAS Pixel data: eCommerce events (product views, purchases)
CRM data: First-party customer information
Third-party segments: Integrated audience providers

Segments are evaluated in real-time during ad decisioning to enable precise targeting.

Ad Delivery Workflow

The complete ad delivery workflow consists of five phases:

sequenceDiagram
    participant User
    participant SDK/API
    participant Bidder
    participant Inventory
    participant Audience
    participant Campaign
    participant Creative
    participant Pixel

    User->>SDK/API: 1. Page Load / Ad Request
    SDK/API->>Bidder: 2. Ad Request (ad_unit, user_id, context)

    Note over Bidder: Phase 1: Validation
    Bidder->>Inventory: Validate ad_unit
    Inventory-->>Bidder: Ad Unit config

    Note over Bidder: Phase 2: User Resolution
    Bidder->>Audience: Resolve user segments (LU/AID)
    Audience-->>Bidder: User segments

    Note over Bidder: Phase 3: Ad Selection
    Bidder->>Campaign: Find eligible line items
    Campaign-->>Bidder: Candidate line items
    Bidder->>Bidder: ML-based ranking

    Note over Bidder: Phase 4: Creative Selection
    Bidder->>Creative: Select creative for winner
    Creative-->>Bidder: Creative assets

    Note over Bidder: Phase 5: Rendering
    Bidder-->>SDK/API: Ad markup (HTML/JS)
    SDK/API-->>User: Render ad

    User->>Pixel: 6. Impression tracking
    User->>Pixel: 7. Click tracking (if clicked)
    Pixel-->>Campaign: Update metrics

Phase 1: Request Validation

When an ad request arrives, the Bidder validates:

Ad Unit ID: Ensures the placement exists and is active
Network ID: Verifies the request is for the correct tenant
Request format: Validates required parameters
Rate limits: Checks if the request is within quota

Invalid requests are rejected with appropriate error codes.

Phase 2: User Resolution

The Bidder resolves the user identity using:

LU (Browser ID): Third-party cookie identifier
AID (Account ID): Logged-in user identifier (hashed email)
Device ID: Mobile advertising identifier (IDFA, AAID)

User segments are fetched from the Audience database and cached for the duration of the request.

Phase 3: Ad Selection (Auction)

The Bidder performs a multi-stage auction:

Filtering: Eliminates line items that don't match targeting criteria
Eligibility Check: Verifies budget, flight dates, frequency caps
Ranking: Scores remaining line items using ML models
Winner Selection: Selects the highest-scoring line item

The auction mechanism depends on the campaign type:

Priority-based: Higher priority campaigns win (typical for guaranteed deals)
RTB (Real-Time Bidding): Highest bid wins (typical for programmatic)
Hybrid: Combination of priority and bid price

Phase 4: Creative Selection

Once a line item wins, the Creative Selector chooses the best creative:

Matches ad unit size requirements
Considers device capabilities
Applies A/B testing logic if configured
Selects highest-performing creative if multiple options exist

Phase 5: Rendering & Delivery

The Rendering Engine generates the final ad markup:

Display ads: HTML/JavaScript with image or HTML5 creative
Native ads: JSON response with title, description, image URL
Video ads: VAST XML for video players
Rich media: Custom HTML5 interactive creatives

The ad is delivered to the client for rendering in the browser or app.

Integration Methods

Ring DAS supports three primary integration methods for ad delivery:

1. Client-Side SDK (DL API SDK)

The DL API SDK is a JavaScript library for web browsers that handles:

Ad request construction and submission
User identification (LU/AID)
Creative rendering and display
Impression and click tracking
Viewability measurement

Best for: Publishers with web properties who need quick integration and built-in tracking.

// Initialize DL API SDK
window.DL_API.init({
  networkId: 7012768,
  userId: 'user_123',
  gdprConsent: true
});

// Request an ad
window.DL_API.requestAd({
  adUnitId: 'homepage_banner',
  sizes: [[728, 90], [970, 250]]
});

Learn more about DL API SDK →

2. Server-Side API

The HTTP API allows server-side ad requests for:

Server-side rendering (SSR) applications
Mobile app backends
AMP pages
Custom integrations

Best for: Developers who need full control over the ad request/response cycle.

POST /v1/ad-request HTTP/1.1
Host: api.ringdas.com
Content-Type: application/json
Authorization: Bearer YOUR_API_KEY

{
  "network_id": 7012768,
  "ad_unit_id": "homepage_banner",
  "user": {
    "lu": "abc123",
    "aid": "hashed_email"
  },
  "device": {
    "user_agent": "Mozilla/5.0...",
    "ip": "203.0.113.42"
  },
  "sizes": [[728, 90], [970, 250]]
}

Learn more about Ad Request API →

3. Prebid.js Adapter

Ring DAS provides a Prebid.js adapter for header bidding integrations:

Competes with other demand sources in real-time
Supports standard IAB formats
Integrates with Google Ad Manager (GAM)
Works with all major SSPs and exchanges

Best for: Publishers using header bidding to maximize yield.

// Prebid.js configuration
pbjs.addAdUnits([{
  code: 'homepage_banner',
  mediaTypes: {
    banner: { sizes: [[728, 90], [970, 250]] }
  },
  bids: [{
    bidder: 'ringdas',
    params: {
      networkId: 7012768,
      adUnitId: 'homepage_banner'
    }
  }]
}]);

Learn more about Prebid.js integration →

Campaign Types & Delivery Goals

Ring DAS supports multiple campaign types with different delivery strategies:

Guaranteed Campaigns

Guaranteed campaigns have reserved inventory and delivery commitments:

Priority delivery: Higher priority than non-guaranteed campaigns
Pacing: Even delivery across the flight dates
Budget management: Daily budgets with rollover
Frequency capping: Control how often users see ads

Example use case: A brand books 10 million impressions over 30 days with even pacing.

Programmatic Campaigns

Programmatic campaigns compete in real-time auctions:

RTB auctions: Highest bid wins
Dynamic pricing: Adjust bids based on performance
Budget optimization: Spend budget efficiently
No delivery guarantee: Impressions not guaranteed

Example use case: A performance advertiser runs retargeting campaigns with dynamic CPM bids.

House Campaigns

House campaigns fill unsold inventory:

Lowest priority: Only serve when no paid campaigns match
No cost: Internal or promotional content
Remnant inventory: Fill empty ad slots

Example use case: Publisher promotes their own content or products in unsold ad space.

Budget Management & Pacing

Ring DAS includes sophisticated budget management to ensure campaigns deliver as planned.

Pacekeeper

The Pacekeeper component monitors campaign delivery in real-time and adjusts serving rates:

Compares actual delivery vs. target delivery
Calculates Budget Burn Deviation (BBD)
Adjusts campaign throttling to stay on pace

graph LR
    subgraph "Pacekeeper Logic"
        A[Actual Spend] --> C[Calculate BBD]
        B[Target Spend] --> C
        C --> D{BBD > +10%?}
        D -->|Yes| E[Reduce Serving Rate]
        D -->|No| F{BBD < -10%?}
        F -->|Yes| G[Increase Serving Rate]
        F -->|No| H[Maintain Rate]
    end

Learn more about Pacekeeper →

Frequency Capping

Frequency caps limit how often a user sees the same ad:

Per user: Maximum impressions per user per time period
Per session: Maximum impressions per browsing session
Per creative: Control exposure at creative level

Example: Show max 3 impressions per user per day.

Targeting Capabilities

Ring DAS provides comprehensive targeting options:

Audience Targeting

Target users based on segments:

Behavioral: Users who viewed products, added to cart, purchased
Demographic: Age, gender, location
Custom: First-party CRM segments
Lookalike: Similar users to existing customers

Contextual Targeting

Target based on page context:

Key-value pairs: Custom parameters (e.g., category=electronics)
Content categories: IAB content taxonomy
Keywords: Page keywords and themes

Geographic Targeting

Target by location:

Country: National campaigns
Region/State: Regional campaigns
City: Local campaigns
Postal code: Hyper-local campaigns

Device Targeting

Target by device characteristics:

Device type: Mobile, tablet, desktop
Operating system: iOS, Android, Windows, macOS
Browser: Chrome, Safari, Firefox, Edge
Connection type: WiFi, cellular, broadband

Temporal Targeting

Target by time:

Day of week: Weekday vs. weekend campaigns
Time of day: Daypart targeting (morning, evening, night)
Seasonality: Holiday or event-based campaigns

Performance & Scale

Ring DAS Ad Delivery is designed for massive scale:

Performance Metrics

Request latency: p95 < 100ms, p99 < 200ms
Throughput: 100,000+ requests per second
Availability: 99.95% uptime SLA
Cache hit rate: >95% for campaign data

Rate Limits

Default rate limits for ad delivery:

Ad requests: 10,000 requests per second per network
Concurrent requests: 1,000 per client IP
Daily impressions: No hard limit (throttled based on budget)

Learn more about rate limits →

Geographic Distribution

Ring DAS operates in multiple regions for low-latency delivery:

Europe: Frankfurt, London
Asia: Singapore, Tokyo
Americas: Virginia, São Paulo

Requests are automatically routed to the nearest region.

Optimization & Machine Learning

Ring DAS uses machine learning to optimize ad delivery:

Smart Deals

Smart Deals automatically adjust campaign parameters:

Dynamic CPM: Adjust bids based on predicted conversion probability
Budget allocation: Distribute budget across line items optimally
Audience expansion: Discover new high-performing segments
Creative rotation: Favor best-performing creatives

Predictive Models

The Bidder uses ML models to predict:

Click-through rate (CTR): Probability user will click
Conversion rate (CVR): Probability user will convert
Viewability: Probability ad will be viewable
Revenue: Expected revenue per impression

These predictions inform the auction ranking algorithm.

Security & Privacy

Ring DAS prioritizes user privacy and data security:

GDPR Compliance

Consent management: Integration with TCF 2.0 consent strings
User rights: Support for data access, deletion, portability
Data minimization: Only collect necessary data

Privacy Features

Contextual targeting: Target without personal data
Cohort-based targeting: Group-level targeting (no individual profiling)
First-party data: Use advertiser's own customer data

Anti-Fraud

Traffic validation: Detect invalid traffic (IVT)
Device fingerprinting: Identify suspicious patterns
Rate limiting: Prevent abuse and scraping

Monitoring & Troubleshooting

Ring DAS provides tools for monitoring ad delivery:

Real-Time Dashboards

Delivery metrics: Impressions, clicks, revenue by campaign
Performance trends: Hour-over-hour, day-over-day comparisons
Budget pacing: Actual vs. target delivery
Error rates: Failed requests, timeouts, invalid ads

Debugging Tools

Ad Inspector: Browser extension to see ad decisioning details
Request logs: Detailed logs of ad requests and responses
Test mode: Preview ads without counting impressions

Learn more about Ad Inspector →

Alerts & Notifications

Configure alerts for:

Under-delivery: Campaign not pacing correctly
Budget exhaustion: Campaign running out of budget
Error spikes: Increased request failures
Performance degradation: Latency or availability issues

Best Practices

Follow these best practices for optimal ad delivery:

For Publishers

Implement lazy loading: Only request ads when needed
Use refresh strategies: Refresh ads on viewable slots only
Optimize ad unit placement: Place ads where they're most viewable
Monitor performance: Track fill rate, viewability, revenue
Test integrations: Use test mode before going live

For Advertisers

Use audience targeting: Leverage first-party data for better performance
Set realistic budgets: Ensure budgets support delivery goals
Optimize creatives: Test multiple creative variations
Monitor pacing: Check daily delivery vs. targets
Analyze performance: Review reports regularly and adjust campaigns

For Developers

Cache ad responses: Reduce duplicate requests
Handle errors gracefully: Implement fallback ad logic
Respect rate limits: Implement exponential backoff
Send required parameters: Include all targeting signals
Track impressions accurately: Follow IAB standards

What's Next?

Now that you understand how Ring DAS Ad Delivery works, explore these topics:

Ad Request Handling - Learn how to construct and submit ad requests
Creative Rendering - Understand creative display and rendering
Tracking & Measurement - Implement viewability and click tracking
DL API SDK - Integrate the JavaScript SDK
Prebid.js Integration - Set up header bidding
Ad Decision Engine - Deep dive into the Bidder
Smart Deals - Use ML-based optimization

Support

Need help with Ring DAS Ad Delivery?

Documentation: docs.ringdas.com
API Reference: API Documentation
Support Portal: support.ringdas.com
Technical Support: [email protected]