Skills projection-patterns
📦

projection-patterns

Low Risk 🌐 Network access⚙️ External commands

Implement CQRS Projection Patterns

Event-sourced systems need efficient read models for high-performance queries. This skill provides production-ready templates and patterns for building projections, read models, and materialized views from event streams using Python.

Supports: Claude Codex Code(CC)
📊 69 Adequate
1

Download the skill ZIP

2

Upload in Claude

Go to Settings → Capabilities → Skills → Upload skill

3

Toggle on and start using

Test it

Using "projection-patterns". Create a basic order summary projection

Expected outcome:

  • Event handler for OrderCreated: Insert new order summary record with customer data
  • Event handler for OrderItemAdded: Update total_amount and increment item_count
  • Event handler for OrderShipped: Set status to shipped and record shipped_at timestamp
  • Checkpoint tracking: Store global_position after each processed event
  • Idempotent design: Safe to replay events on system restart

Using "projection-patterns". Build a customer activity tracker projection

Expected outcome:

  • CustomerCreated handler: Insert customer record and initialize activity summary
  • OrderCompleted handler: Update total_orders and total_spent in summary table
  • OrderCompleted handler: Insert into order history table for audit trail
  • ReviewSubmitted handler: Increment review count and record last review date
  • CustomerTierChanged handler: Update tier and tier change timestamp

Using "projection-patterns". Implement a real-time sales dashboard projection

Expected outcome:

  • OrderCompleted handler: Upsert daily sales record with new order totals
  • OrderRefunded handler: Decrement revenue and increment refund totals
  • Date extraction: Parse completion date to group sales by day
  • Atomic updates: Use database ON CONFLICT for race condition safety
  • Metric calculations: Track total orders, revenue, items, and refunds per day

Security Audit

Low Risk
v4 • 1/17/2026

This skill is documentation-only containing Python code templates for CQRS projection patterns. Static scanner flagged 42 patterns, but all are false positives triggered by documentation formatting and terminology. No executable code, network calls, or system modifications exist. The skill only provides architectural guidance via markdown templates.

2
Files scanned
664
Lines analyzed
2
findings
4
Total audits

Risk Factors

🌐 Network access (3)
skill-report.json:6 SKILL.md:487 SKILL.md:488
⚙️ External commands (11)
SKILL.md:23-32 SKILL.md:32-47 SKILL.md:47-120 SKILL.md:120-124 SKILL.md:124-246 SKILL.md:246-250 SKILL.md:250-315 SKILL.md:315-319 SKILL.md:319-372 SKILL.md:372-376 SKILL.md:376-468
Audited by: claude View Audit History →

Quality Score

38
Architecture
100
Maintainability
87
Content
30
Community
90
Security
91
Spec Compliance

What You Can Build

Build Read Models

Transform event streams into optimized read models for your CQRS architecture.

Create Analytics Views

Build real-time aggregated views for dashboards and reporting systems.

Design Event Systems

Plan and implement projection strategies for event-sourced microservices.

Try These Prompts

Basic Projection 
Create a basic projection class that handles OrderCreated and OrderCompleted events from an event stream and updates a PostgreSQL read model.
Multi-Table Update 
Write a projection that updates both a customer summary table and order history table when an OrderCompleted event occurs, using a single database transaction.
Search Index Sync 
Create an Elasticsearch projection that indexes product events for full-text search, handling create, update, and delete operations.
Daily Metrics 
Write a projection that aggregates sales data by day, handling both completed orders and refunds with upsert logic.

Best Practices

  • Make projections idempotent so they can safely replay events after failures or restarts
  • Use database transactions when a single event updates multiple related tables
  • Store checkpoints to enable resumption from the last processed event position

Avoid

  • Coupling projections together creates cascade failures and tight ordering dependencies
  • Skipping error handling causes silent failures and data inconsistency in read models
  • Over-normalizing read models defeats the purpose of projections by adding join complexity

Frequently Asked Questions

Which databases work with these projections?
Templates use asyncpg for PostgreSQL but the patterns apply to any async database driver like SQLAlchemy or databases with async support.
How do projections handle high event volumes?
Implement batch processing with configurable batch_size and checkpointing to manage memory and enable restart capability.
Can I use these patterns with Kafka?
Yes, the projector pattern works with any event source. Replace the event_store.read_all() call with your Kafka consumer logic.
Is my data safe with these projections?
These are architectural templates. Actual data safety depends on your database permissions, connection security, and access controls.
Why is my projection falling behind the event stream?
Check event batch size, database query performance, and ensure proper indexing on read model tables for event data patterns.
How is this different from ETL pipelines?
Projections process events in order as they occur, maintaining state. ETL typically runs batch jobs on historical data without real-time updates.

Developer Details

Author

wshobson

License

MIT

Repository

https://github.com/wshobson/agents/tree/main/plugins/backend-development/skills/projection-patterns

Ref

main

File structure

📄 SKILL.md