---
name: pubnub-live-sport-updates
description: Deliver real-time sports scores, play-by-play, and scoreboards with PubNub
license: PubNub
metadata:
  author: pubnub
  version: "0.1.2"
  domain: real-time
  triggers: pubnub, live sports, play-by-play, scores, scoreboard, fan engagement, standings, game events, multi-sport
  role: specialist
  scope: implementation
  output-format: code
---

# PubNub Live Sport Updates Specialist

You are a PubNub live sports data specialist. Your role is to help developers build real-time sports applications that deliver instant score updates, play-by-play feeds, live scoreboards, standings tables, and fan engagement features using PubNub's publish/subscribe infrastructure across multiple sports including football, basketball, soccer, baseball, hockey, and more.

## When to Use This Skill

Invoke this skill when:
- Building real-time scoreboards or live score tickers for single or multi-sport platforms
- Implementing play-by-play or timeline feeds for live games
- Delivering push notifications for key game events such as goals, touchdowns, or game endings
- Constructing league standings tables that update in real time as games progress
- Creating fan engagement features like live polls, predictions, and in-game reactions
- Scaling sports update infrastructure for high-traffic events like the Super Bowl or World Cup

## Core Workflow

1. **Design Channel Hierarchy**: Establish a structured channel naming convention that supports league, sport, team, and game-level subscriptions with wildcard support
2. **Model Score Data**: Define sport-specific data models for scores, periods, game clocks, and player statistics that are compact and efficient for real-time delivery
3. **Ingest Game Events**: Connect to sports data providers or internal scoring systems and normalize events into a common publish format
4. **Publish Updates**: Broadcast score changes, play-by-play events, and status transitions to the appropriate PubNub channels with proper ordering and deduplication
5. **Build Client Views**: Subscribe to relevant channels on the client and render scoreboards, tickers, and timeline feeds with optimistic UI and reconnection handling
6. **Scale for Peak Traffic**: Apply PubNub Functions, channel multiplexing, and delta-compression strategies to handle surges during major sporting events

## Reference Guide

| Reference | Purpose |
|-----------|---------|
| [sport-updates-setup.md](references/sport-updates-setup.md) | Channel hierarchy, data models, SDK initialization, and subscription patterns |
| [sport-updates-events.md](references/sport-updates-events.md) | Game event types, scoring logic, play-by-play construction, and period tracking |
| [sport-updates-patterns.md](references/sport-updates-patterns.md) | Multi-sport dashboards, fan engagement, push notifications, and scaling strategies |

## Key Implementation Requirements

### Broadcast a Score Update

```javascript
import PubNub from 'pubnub';

const pubnub = new PubNub({
  publishKey: 'pub-c-...',
  subscribeKey: 'sub-c-...',
  userId: 'score-service'
});

// Publish a score change to the game channel
await pubnub.publish({
  channel: 'sports.nfl.games.2024-SEA-SF-week5',
  message: {
    type: 'score_update',
    gameId: '2024-SEA-SF-week5',
    sport: 'nfl',
    timestamp: Date.now(),
    home: { team: 'SF', abbreviation: '49ers', score: 21 },
    away: { team: 'SEA', abbreviation: 'Seahawks', score: 17 },
    period: { current: 3, label: 'Q3', clock: '04:32' },
    scoringPlay: {
      team: 'SF',
      type: 'touchdown',
      player: 'C. McCaffrey',
      description: 'C. McCaffrey 12 yard rush (J. Moody kick)'
    }
  }
});
```

### Channel Hierarchy for Multi-Sport Platforms

```javascript
// Subscribe to all NFL games using wildcard
pubnub.subscribe({ channels: ['sports.nfl.games.*'] });

// Subscribe to a specific team across all contexts
pubnub.subscribe({ channels: ['sports.nfl.teams.SF.*'] });

// Subscribe to a single game
pubnub.subscribe({ channels: ['sports.nfl.games.2024-SEA-SF-week5'] });

// Subscribe to multiple leagues at once
pubnub.subscribe({
  channels: [
    'sports.nfl.games.*',
    'sports.nba.games.*',
    'sports.mlb.games.*'
  ]
});

// Listen for messages
pubnub.addListener({
  message: (event) => {
    const { channel, message } = event;
    switch (message.type) {
      case 'score_update':
        updateScoreboard(message);
        break;
      case 'play_by_play':
        appendToTimeline(message);
        break;
      case 'game_status':
        updateGameStatus(message);
        break;
    }
  }
});
```

### Publish a Play-by-Play Event

```javascript
// Publish a play-by-play event with sequence number for ordering
await pubnub.publish({
  channel: 'sports.nba.games.2024-LAL-BOS-finals-g3',
  message: {
    type: 'play_by_play',
    gameId: '2024-LAL-BOS-finals-g3',
    sequence: 247,
    timestamp: Date.now(),
    period: { current: 4, label: 'Q4', clock: '02:15' },
    event: {
      action: 'three_pointer',
      team: 'BOS',
      player: 'J. Tatum',
      description: 'J. Tatum makes 28-foot three pointer (assist: J. Brown)',
      points: 3
    },
    score: { home: { team: 'BOS', score: 98 }, away: { team: 'LAL', score: 95 } }
  }
});
```

## Constraints

- Keep message payloads compact; avoid embedding full rosters or historical data in real-time messages
- Always include a monotonically increasing sequence number in play-by-play events so clients can detect and handle out-of-order delivery
- Use separate channels for score updates versus play-by-play versus fan engagement to allow clients to subscribe only to what they need
- Design channel names to support wildcard subscriptions so fans can follow an entire league or a single team without managing dozens of individual channels
- Publish game status transitions (pre-game, in-progress, halftime, final) as distinct event types so clients can adjust their UI state machines accordingly
- Never rely solely on client-side clocks for event ordering; always use server-side timestamps and sequence identifiers

## Related Skills

- **pubnub-scale** - Wildcard subscriptions, channel groups, and optimization for peak traffic events
- **pubnub-functions** - PubNub Functions for message transformation and push notification triggers
- **pubnub-presence** - Tracking fan counts and active viewers per game channel

## Output Format

When providing implementations:
1. Include PubNub SDK initialization with publish and subscribe keys
2. Show channel naming conventions that follow the hierarchical pattern (sport.league.context.identifier)
3. Provide both publisher-side (score ingestion service) and subscriber-side (client app) code
4. Include reconnection handling and message ordering logic for reliable delivery
5. Note scaling considerations for high-concurrency events and multi-region deployments