Hedge inputs, comp inputs, lock exceptions — on one event stream.
Secondary teams need pristine inputs for hedging, bid tapes, and pull-through analysis. RateStack ships price discovery, sell-side pricing, lock state, exception lifecycle, and a hash-chained audit log over a single event backbone — every event tagged with a correlationId you can use as a join key downstream. Pair this with the in-platform Hedge Cockpit when you want the desk in one screen.
Secondary marketing is the consumer of every other RateStack subsystem. You need inputs that reconcile: today's price discovery, lock-day commitments, sell-side execution, exception detection, and the audit trail behind every state change. RateStack's NATS JetStream backbone delivers all of those with retention windows tuned for secondary use (7-180 days depending on stream) and a stable correlationId thread.
Webhook deliveries carry HMAC-SHA256 signatures and the same correlationId your hedge stack is already using. Failed deliveries land in a DLQ that's queryable and replayable; you're never silently missing events. The new exception.* event stream surfaces detector fires (pricing drift, pullthrough drift, sell-side mismatch) — your downstream model can act on the same signal the platform-internal Exception Inbox shows.
Sell-side pricing runs against your buy-side investor pack with completion audit per investor. Bid-tape reconciliation is a join on lockId + sellSideId — no string matching, no fuzzy timestamp windows. And when you want the desk view inside the platform, the Hedge Cockpit reads from the same stream.
Before vs. after
The shape of a day.
The same operating model, rebuilt around explicit pricing and a single audit log.
Before
Pricing, lock, exception, and sell-side data live in four systems with four vocabularies.
After
One platform, one event stream, one correlationId.
Before
Hedge inputs reconstruct events from logs because no one shares a join key.
After
Subscribe pricing.computed, locks.*, and exception.* webhooks — they share correlationId by construction.
Before
Lock exceptions reach hedge by email or not at all.
After
exception.* webhook stream with HMAC + DLQ. Build whatever downstream you want; the data flows reliably.
Before
Bid-tape reconciliation is fuzzy timestamp + investor name matching.
After
Sell-side completion writes a row with lockId + sellSideId; reconciliation is a join, not a guess.
Capabilities, framed for you
The platform pieces you'll touch first.
Event-driven primary feed
NATS JetStream with 7-180 day retention per stream type.
Webhooks with DLQ
HMAC-signed; 8 retries; DLQ replay; per-subscriber bulkhead.
Exception event stream
exception.* events stream alongside pricing.computed and locks.*.
Hedge cockpit (in-platform view)
Same event stream rendered as a live desk dashboard.
Sell-side pricing
Same input + pin as loan-level lock; per-investor completion audit.
Pricing replay as-of
Reprice any historical loan against the ratesheet active at that moment.
Hash-chained audit
Tamper-evident; verify endpoint reports first break.
API + GraphQL
Pull whatever push misses. OpenAPI spec, idempotency keys.
Onboarding
What week one looks like.
A pragmatic sequence — from sandbox to first signed quote.
- 1
Day 1: subscribe events
Subscribe pricing.computed, locks.*, exception.* — point at your event sink. HMAC verify on delivery; eventId as idempotency key.
- 2
Week 1: hedge stack integration
Map RateStack events into your hedge stack's vocabulary. The correlationId becomes your join key.
- 3
Week 2: bid-tape reconciliation
Subscribe sell-side completion events; reconcile against your investor settlements on lockId + sellSideId.
- 4
Week 3: pull-through analytics
Lock lifecycle journal + exception stream feed your pull-through model with deterministic state transitions.
- 5
Week 4: replay validation
Validate historical replay produces the same prices you settled at. The trace explains any divergence.
- 6
Week 5: Hedge Cockpit ride-along
Optionally turn on the in-platform cockpit. It reads the same stream and renders a desk view your team can use directly.
Frequently asked
Specific to your operating model.
What's the event retention?
Configurable per stream. Defaults: pricing 7d, ratesheets 90d, locks 180d, exceptions 90d, audits indefinite. Increase per environment.
Can we get a Kafka bridge?
Yes. NATS-to-Kafka bridges are first-party on the Enterprise tier; talk to sales for the deployment options.
Do you support real-time streaming over WebSocket?
SSE for the platform's Exception Inbox; webhooks for cross-system delivery. WebSocket on the roadmap. Most secondary stacks pull via webhook subscriptions for ordering guarantees.
What if our hedge model needs intra-day pricing snapshots?
Schedule a snapshot via the cron / event orchestrator (fetch-service); pricing-service emits pricing.snapshot with the timestamp anchor and the correlationId.
Can we render the cockpit in our own UI?
Yes. The cockpit's data endpoints are public REST; embed sparklines, P&L, and exceptions wherever you want. Cockpit's own UI is also rendered if you keep operators in-platform.
Ready when you are
See secondary marketing on RateStack.
Live demo with your real ratesheets, your real scenarios, and an honest read on whether the platform fits your team.