Use Cases

Real-world scenarios where EdgeStream excels

Where EdgeStream Shines

EdgeStream is designed for systems that need reliable, efficient real-time message handling. Here are proven scenarios where it delivers exceptional value.

Primary Use Cases

💰 Financial Trading & Payments

Real-time market data, trade execution notifications, and payment status updates require instant, reliable message delivery with zero data loss.
  • High-frequency trade notifications (100+ msg/sec)
  • Payment status tracking with LRU-bounded history
  • Price update broadcasts via SSE or WebSocket
  • DIDComm v2 for secure credential exchange
  • Approval workflows for large transactions
  • Backpressure handling during market spikes

🏥 Healthcare Systems

Patient alerts, appointment reminders, and clinical decision support demand reliable delivery with HIPAA-compliant encryption and audit trails.
  • Patient emergency alerts with priority routing
  • Appointment & prescription reminders
  • Test result notifications
  • Clinical workflow state machine (approvals, consults)
  • End-to-end encryption via DIDComm
  • Message correlation for audit compliance

🏭 Manufacturing & IoT

Sensor data streams, production monitoring, and error handling at scale need memory-efficient caching and worker thread offload for CPU-heavy tasks.
  • Sensor telemetry at 100+ readings/sec
  • Production line status updates
  • Equipment failure alerts
  • Predictive maintenance data correlation
  • Worker threads for data transformation
  • LRU cache for rolling window analytics

🛒 E-Commerce Platforms

Order tracking, inventory updates, and customer notifications at scale demand flexible protocol support and composable pipelines for different message types.
  • Real-time order status to customers
  • Inventory synchronization across warehouses
  • Push notifications for promotions
  • Returns & refund workflows
  • CloudEvents for inventory feed
  • React batching for checkout progress updates

🎮 Gaming & Real-time Multiplayer

Game state synchronization, player actions, and matchmaking require sub-100ms latency with support for batching updates and handling dropouts gracefully.
  • Player action broadcasting to game state server
  • Game state updates to all players
  • Matchmaking notifications
  • Leaderboard updates
  • WebSocket for low-latency delivery
  • Bounded queue for backpressure under load

📊 Business Analytics & Dashboards

Real-time metrics, live dashboards, and business intelligence streams benefit from protocol normalization and React integration for responsive UIs.
  • Live dashboard metrics updates
  • Sales funnel tracking in real-time
  • User activity streams
  • Custom report data feeds
  • React components auto-update via useMessages
  • LRU cache for rolling metrics windows

🔧 DevOps & Monitoring

Server monitoring, log streaming, and alerting require multi-protocol support and the ability to compose different handling rules per message type.
  • Server health metrics streaming
  • Log aggregation and alerting
  • Deployment notifications
  • Incident escalation workflows
  • Multiple protocol support (JSON, CloudEvents)
  • Composable hooks for filtering & routing

🎓 Collaborative & Education Platforms

Real-time collaboration, class notifications, and student interactions benefit from pause/resume for interactive workflows and message correlation.
  • Live class updates and virtual classroom events
  • Student assignment submissions
  • Grade notifications
  • Real-time document collaboration
  • Interactive approval workflows for assignments
  • Message correlation for submission tracking

Deep Dive: Financial Trading Example

How EdgeStream powers a real-time trading platform:

graph TB A["💹 Server
100+/sec"] -->|Data| B["📡 Transport"] B -->|Raw| C["🔍 Parser"] C -->|Parsed| D["⚙️ Pipeline"] D -->|Transform| E["🔐 Decrypt"] E -->|Validate| F["🔗 Filter"] F -->|Publish| G["📊 Subscribe"] G -->|USD| H["👨 Trader"] G -->|EUR| I["📈 Analytics"] H -->|React| J["💻 UI"] I -->|Cache| K["💾 LRU"]

Pipeline Configuration

const tradingStream = createEdgeStream({ logLevel: 'info' })
  .register({
    type: 'trading',
    url: 'https://trading-server.example.com/signalr'
  })
    .transport({ type: 'signalr' })
    .protocol('custom-binary')  // Custom protocol parser
    .incoming()
      .add(new LogHook({ label: 'PRICE' }))
      .add(new DecryptHook({ privateKeyId: 'trader-key' }))
      .add(new ValidationHook({ schema: priceSchema }))
      .add(new FilterHook({
        predicate: (envelope) => {
          // Only process significant price movements
          return envelope.body.priceChange > 0.5;
        }
      }))
      .add(new PublishToSubscribersHook())
    .done()
  .done()
  .build();

// React component updates live
function TradingDashboard() {
  const prices = useMessages('trading', 'price.*');
  const status = useConnectionStatus('trading');

  return (
    <>
      {prices.map(p => (
        <PriceCard
          key={p.meta.id}
          currency={p.body.currency}
          price={p.body.price}
          change={p.body.priceChange}
        />
      ))}
    </>
  );
}

Why EdgeStream for Trading

Why Not Just Use X?

Comparison: Different Tools for Different Jobs

Raw WebSocket

Pro: Low overhead

Con: No fallback, no protocol abstraction, manual message handling

SignalR Only

Pro: Automatic fallback

Con: Single protocol, no composable hooks, no pause/resume

Socket.io

Pro: Good for real-time

Con: Tightly coupled to Node.js, not portable

EdgeStream

Pro: Multi-transport, protocol-agnostic, composable, scalable

Con: Slight overhead vs raw WebSocket (but gains outweigh)

EdgeStream is for teams that: