skills.rest
NorkzYT
NorkzYTCOMMUNITY
Explore all skills by this author →
GitHub

projection-patterns

Design and implement projections and read models from event streams.

2|2|Updated Jan 21, 2026
Search Tags:#CQRS#projection#event-sourcing#read-model#data-architecture#stream-processing
One-click install
npx skills add https://github.com/NorkzYT/claude-code-autopilot --skill projection-patterns-norkzyt
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: projection-patterns
Source: https://github.com/NorkzYT/claude-code-autopilot/tree/main/.claude/skills/projection-patterns
Command: npx skills add https://github.com/NorkzYT/claude-code-autopilot --skill projection-patterns-norkzyt

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Projections and read models from event streams enable fast, scalable queries and decoupled read paths in event-sourced systems.

Core Features & Use Cases

  • Live projections: build real-time read models from ongoing events for dashboards and fast queries.
  • Catch-up projections: rebuild read models from historical events after outages or migrations.
  • Persistent checkpoints: store progress to resume after restarts and ensure recoverability.
  • Multi-store targets: project into SQL, NoSQL, or search indexes to match query patterns.

Quick Start

Use the projection-patterns skill to outline and implement a read model from your event streams. Start by identifying an event stream (e.g., "user-events"), design a read model schema (e.g., a users table), implement a projector to handle relevant events, and verify the read model accuracy against expected queries.

Frequently Asked Questions about projection-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I build fast read models from event streams in a CQRS architecture?▼

Fast read models from event streams are built by implementing projections that process ongoing events into materialized views, enabling decoupled and scalable queries in event-sourced systems. This skill helps design and implement those projectors.

What is the best way to ensure my event-sourcing projections are idempotent and recoverable?▼

Idempotent projections and recoverability are ensured by implementing persistent checkpoints that store processing progress, allowing read models to resume safely after restarts and ensuring reliable data views without duplication.

How do I rebuild a read model from historical events after an outage or migration?▼

Rebuilding read models from historical events is achieved through catch-up projections, which replay past event streams to reconstruct materialized views and restore data accuracy after outages or system migrations.

Can I project event streams into multiple data stores like SQL, NoSQL, and search indexes?▼

Projecting event streams into multiple data stores is fully supported, allowing you to target SQL databases, NoSQL stores, or search indexes to match specific query patterns and optimize read performance across different views.

When do I need projections and materialized views in an event-sourced system?▼

Projections and materialized views are needed when you require fast, scalable queries and decoupled read paths in event-sourced systems, such as for real-time dashboards, reporting, or search indexes without querying the event store directly.

Related Skills

Explore More Software Engineering Skills→
ecotoneframeworkecotoneframework
2

ecotone-event-sourcing

Models domain state as a sequence of events using Ecotone's event store and projections.

Official
Advanced
JhabbigJhabbig

projection-patterns

Builds read models and materialized views from event streams.

Community
Advanced
ccfccf

projection-patterns

Build Python read models from event streams using Live, Catchup, Persistent, and Inline projections.

Community
Intermediate
PriyanshKuniyalPriyanshKuniyal

projection-patterns

Guide building projections and read models for event-sourced architectures.

Community
Advanced