CDC Live Projection

Summary

Lux Sync can publish a live projection from change data capture feeds. A source-side agent watches database or application changes, converts them into compact current-state JSON, and writes that projection to Lux. Target UIs or services subscribe and receive the live state.

Buyer phrase: “I have change feeds or database events, but I need a fast live projection for dashboards, agents, or operational UIs. I do not need Lux to replace my durable CDC platform.”

Buyer Problem

CDC systems are good at detecting and transporting changes, but buyers often still need a realtime current-state view:

• latest account status;
• current order state;
• inventory projection;
• user session state;
• back-office queue state;
• SaaS entitlement projection;
• operational monitoring view.

Durable CDC platforms can be heavy for browser fanout or active state. Lux can consume the compact output of a CDC agent and broadcast the current projection.

Lux Architecture

Lux does not need to connect directly to the database. A buyer-owned source agent connects to the source system, reads changes, compacts or transforms them, and writes the projected state to Lux.

Data path:

1. Source database or application emits changes.
2. Buyer-owned CDC agent reads the change feed.
3. Agent maps changes into a compact projection document.
4. Agent writes the projection to Lux.
5. Lux stores current projection state in memory.
6. Target UI or service receives updates over WebSocket.

Example State

{
  "table": "accounts",
  "lsn": 1002,
  "rows": [
    { "id": "acct_101", "plan": "production", "op": "upsert" },
    { "id": "acct_204", "plan": "business-premium", "op": "upsert" }
  ],
  "source": "cdc-source-agent",
  "summary": "accounts projection lsn=1002 rows=2"
}

Implementation Shape

Use one document per projection:

projection-accounts-current
projection-orders-open
projection-inventory-site-17
projection-entitlements-active

Source agent pseudocode:

for await (const batch of sourceChanges()) {
  const projection = compactChanges(batch);
  await fetch(`${broker}/api/lux/projection-accounts-current`, {
    method: 'PUT',
    headers: {
      authorization: `Bearer ${apiKey}`,
      'content-type': 'application/json'
    },
    body: JSON.stringify({ data: projection })
  });
}

Target UI:

const projection = lux('projection-accounts-current', {
  endpoint: `${broker}/api/lux`,
  websocketUrl: `${wsBroker}/api/lux/stream/projection-accounts-current`,
  apiKey,
  realtime: true
});

await projection.load(renderProjection);

AWS Estate Proof

Scorecard: /mnt/data/ubuntu_data/code/lux/artifacts/usecase-scorecard-aws/20260617T221800Z/scorecard.md

Proof string: accounts projection lsn=1002 rows=2

Result:

• CLI proof: PASS
• Browser Playwright proof: PASS
• PUT ack observed from external operator machine to AWS EC2: 153.869 ms
• WebSocket delivery observed from external operator machine to AWS EC2: 394.927 ms

Timing boundary: this external AWS estate timing includes public network latency.

Customer Data Handling

For buyer-deployed brokers, CDC projection payloads stay in the buyer environment. The buyer owns the source agent, transformation logic, broker placement, and target consumers. Voxell does not need to access the source database or the CDC payload.

Good Fit

Use Lux for:

• live projection from existing CDC feeds;
• browser fanout of compact change state;
• operational read models;
• current account/order/inventory state;
• agent-visible current database state;
• low-latency UI updates derived from database changes.

Poor Fit

Do not use Lux alone as:

• a durable CDC log;
• a replacement for Debezium, Kafka Connect, database replication, or WAL archival;
• an exactly-once delivery system;
• a schema migration engine;
• a long-term replay store.

The clean positioning is: Lux powers CDC-to-live-state projection. The buyer keeps durable CDC and replay in the appropriate system.

FAQ

Can Lux be used with change data capture feeds?

Yes. A buyer-owned CDC agent can read source changes and publish compact projection state to Lux. Lux then broadcasts that projection to target UIs or services.

Does Lux replace Debezium or Kafka?

No. Lux is not a durable CDC platform. It can sit after Debezium, Kafka, a database trigger, WAL reader, or custom source agent to expose the current live projection.

What does the agent on each end do?

The source agent reads changes and writes compact projection state to Lux. The target agent or UI subscribes to Lux and applies the current projection. If durable replay is needed, it remains in the CDC/event platform.

Is this useful for operational dashboards?

Yes. CDC live projection is useful when the buyer wants database changes to appear quickly in dashboards, support tools, agent views, or control-plane screens.