Operational HTTP feeds
Scheduled, schema-controlled HTTP export of computed Genesys Cloud KPIs to systems that expect operational feed contracts — WFM, legacy schedulers and contractual exports. Not BI datasets, not CSV email attachments, not manual exports.
At a glance
Production-proven- What it delivers
- Scheduled HTTP POST/PUT with an agreed JSON or XML payload, per profile.
- Who consumes
- WFM, legacy workforce schedulers, client reporting buses and middleware.
- Source path
- Reactive Engine → metrics store → feed export service (timer-driven).
- Status
- Production patterns on enterprise Genesys programs.
- Why it matters
- The primary differentiator vs. dashboard vendors and BI-only connectors.
Actuals are aligned to plan in the exact interval, timezone and shape your workforce tooling expects.
Which KPIs, which dimensions, which latency and which schema version — all contracted and reconciled.
The runbook replays an interval from metrics-store history if a downstream window is missed.
Operational feed contracts pay off at enterprise scale — telco and BPO programs especially.
Overview
The feed between Genesys and WFM is a contract
Workforce management plans in intervals and needs actuals aligned to plan in the same shape its tooling expects. When that contract is implemented as a brittle script, programs fail quietly — especially after routing changes or migration.
Schema, schedule and reconciliation — engineered
Each feed is defined by a KPI mapping matrix, a versioned payload schema, an explicit cadence and latency, and acceptance tolerances reconciled against the Genesys source. It is decoupled from per-event UI updates and runs on a timer reading the metrics store — exactly how WFM tools ingest.
- KPI mapping matrix signed in discovery
- Versioned schema with acceptance tolerances (e.g. ±2%)
- Retry, dead-letter and replay-from-history runbook
One source of truth ends the reconciliation meeting
When the feed and Power BI are sourced from the same computed documents, a Monday-morning dispute about service level narrows to a true operational question — an interval boundary, say — instead of a two-hour argument about which integration is wrong.
- Feed and dashboard share one computed definition
- Disputes narrow to operations, not integration errors
- Migration parity with legacy feed contracts
Powered by the Reactive Engine
Every connector is a thin package on one proven core
This connector does not re-implement Genesys integration. It is a focused Global.Platform.* egress package bound to the same Reactive Engine that powers Power BI, operational HTTP feeds and the rest of the catalog. The hard part — correlating the Genesys event stream into trustworthy operational KPIs — is solved once and reused everywhere.
- One ingestion and reactive processing pipeline, many destinations
- Adding a sink is a connector, not a re-architecture
- Consistent KPI semantics across every downstream system
Platform capabilities
The engine guarantees behind every delivery
This connector inherits the correctness, durability and governance of the Reactive Engine — not just a pipe to a destination.
Deterministic reactive processing
The engine computes each KPI from the raw event stream with explicit, reviewable semantics — not opaque aggregates you can't reconcile.
Durable log & replay
An ordered, durable event log lets you recompute, backfill and audit any interval with confidence after a config change.
Idempotent delivery
Keyed envelopes with timestamps let every downstream consumer dedup safely on retry, replay or backfill.
Schema & version governance
Payload contracts are versioned per connector, so consumers upgrade on their own schedule without surprise breakage.
Backpressure & retry
Retry-with-backoff and dead-letter patterns keep transient downstream failures from ever losing a KPI.
Fan-out from one source
Mix real-time streaming and scheduled feeds to many destinations from a single, consistent source of truth.
Integration depth
How deep the integration goes
Integration is a spectrum, not a checkbox. Genesys operational truth is exposed through the Streamvane platform deployed in your Azure — from straightforward egress to a connector embedded in your processing path.
Compute & deliver
The default for most connectors: Genesys operational KPIs are computed once and delivered outward to your destination — streaming or scheduled.
- Read-oriented egress of computed metrics
- Streaming push or scheduled feed cadence
- Same KPI semantics as every other sink
Operational contracts
Schema-controlled, SLA-bound feeds with reconciliation and acceptance criteria — the contract-grade integration WFM and BPO programs depend on.
- Versioned payload schema with acceptance tolerances
- Interval discipline, timezone and latency contracted
- Reconciliation against Genesys source built in
Embedded in your platform
Streamvane is deployed plug-and-play — down to components and code — inside your own cloud subscription on Azure, AWS or GCP, sitting in the Genesys processing path. Genesys operational truth is exposed through our offering, not a brittle hand-built API scrape that drifts on every routing change. Prefer not to operate it? Run the same engine as a managed PaaS bridge instead.
- Deployed into your event mesh and data plane, on Azure, AWS or GCP
- Plug-and-play components, or fully managed as a PaaS
- Extensible with new Global.Platform.* packages
Security
Your data, your tenant, your keys
Security isn't an afterthought bolted onto an export — it's the architecture. Genesys operational data is processed and stored inside your own Azure subscription, under your governance.
Client-owned cloud & data residency
When embedded, Genesys data is ingested, computed and stored inside your own subscription and region — on Azure, AWS or GCP — never transiting or resting in a vendor-controlled cloud.
Encryption in transit & at rest
TLS 1.2+ to every endpoint and Azure storage encryption at rest, with customer-managed keys where your policy requires them.
Secrets in Key Vault, no creds in code
Connection strings, tokens and certificates live in your Key Vault and are read with Managed Identity — never embedded in configuration or source.
RBAC & least privilege
Every component runs with scoped Azure RBAC roles and the minimum permissions needed for its sink — auditable and reviewable.
Network isolation
Private endpoints, VNet integration and IP allow-listing or mTLS keep traffic on private paths where downstream security requires it.
Audit & observability
Diagnostic logs and Application Insights give you a full audit trail of what was produced, when, and to which destination.
DevOps & SecOps
Built to live in your software lifecycle
The connector is engineered, versioned and operated like any other service in your estate — provisioned as code, shipped through your pipelines, governed by your release process.
Infrastructure as Code
The whole footprint — Service Bus, the metrics store, Key Vault, workers and the connector — is provisioned from Bicep or Terraform you can review and own.
CI/CD pipelines
Build, test and deploy through your Azure DevOps or GitHub Actions pipelines, with the connector versioned like any other service.
Environment promotion
Dev, test and production parity with config-driven KPI profiles, so a feed proven in test promotes cleanly to production.
Config & secrets management
KPI profiles, schedules and endpoints are configuration — managed in App Configuration and Key Vault, not hard-coded redeploys.
Observability & SLOs
Health, lag and throughput are surfaced as metrics and alerts so operations teams trust the numbers and catch drift early.
Security in the pipeline (SecOps)
Dependency and static analysis run in the pipeline, with change control and SecOps gates aligned to your release process.
Technical reference
The details engineers will ask for
What gets decided in discovery and what delivery actually involves.
Feed design components
The deliverables that turn a vague export request into an accountable operational contract.
| Component | What it pins down |
|---|---|
| KPI mapping matrix | Business KPI ↔ Genesys source, dimensions, formula narrative, reconciliation |
| Payload schema | Version field, interval boundaries, metric arrays, null-handling rules |
| Schedule & latency | reactive latency + export cadence = contracted end-to-end latency |
| Reliability | Retry with backoff, dead-letter/alert queue, replay runbook |
| Acceptance | e.g. 95% of intervals delivered within N minutes of interval close |
Why not a simpler export?
Ad-hoc exports and BI connectors solve a different problem than an operational feed contract.
| Approach | Fit | Gap |
|---|---|---|
| Genesys CSV export | Ad hoc | Manual, not contractual |
| AppFoundry Power BI connector | BI | Not a WFM feed schema |
| SI custom HTTP job | One-off | Expensive, fragile, drifts |
| Streamvane HTTP feeds | Operational contracts | Requires discovery + acceptance |
Frequently asked
Can feeds and Power BI coexist?
Yes — they share the same Reactive Engine. The feed and the dashboard are sourced from the same metrics-store documents, so the numbers agree.
What happens when Genesys routing changes?
A change process for routing and configuration updates is agreed in discovery, and reconciliation catches drift before it reaches the downstream contract.
Is there a minimum scale?
Operational feed contracts typically pay off from around 500+ agents, where interval discipline and reconciliation matter most.
JSON or XML?
Either — the payload schema is profile-specific and agreed in discovery, with a version field carried in every payload.
See this connector running on your Azure tenant
Book a scoping call and we'll map your KPI families to this destination — with the security, lifecycle and depth of integration your teams require.
Streamvane by Tessovia · Azure · AWS · GCP · Your data, your keys