Senior data engineer

Data engineering skill for building scalable data pipelines, ETL/ELT systems, and data infrastructure.

How to use it

Claude Code
  1. Run the line below. It pulls the whole folder into ~/.claude/skills/senior-data-engineer.
  2. Describe your job in plain words. Claude Code follows the skill from there.
Claude Code — installs the whole folder, not just SKILL.md
npx degit alirezarezvani/claude-skills/engineering-team/skills/senior-data-engineer#main ~/.claude/skills/senior-data-engineer

For one project only, change the path to .claude/skills/senior-data-engineer.

Claude (web or desktop app)
  1. On this page open ⋯ → Download .md.
  2. Save it as SKILL.md in a folder, zip the folder, then Customize → Skills → + → Create skill → Upload a skill.
  3. Pick the file and Save. Claude shows the name and description and runs a security scan.
  4. Check the skill is switched on.
  5. Start a new chat and describe your job in plain words. The AI follows the skill from there.
ChatGPT or another app
  1. ChatGPT: make a Project and paste it into Instructions.
  2. Neither? Paste it at the top of a new chat — it works for that chat.
Not working?
  • Check which app you pasted it into — the steps above name the right one.
  • Some skills need the paid tier of Claude or ChatGPT.
Step-by-step guide with screenshots · Ask in the forum

Paste into Claude, ChatGPT or Cursor.

Source of Senior data engineer

Show the full text192 lines
namedescription
senior-data-engineerData engineering skill for building scalable data pipelines, ETL/ELT systems, and data infrastructure. Expertise in Python, SQL, Spark, Airflow, dbt, Kafka, and modern data stack. Includes data modeling, pipeline orchestration, data quality, and DataOps. Use when designing data architectures, building data pipelines, optimizing data workflows, implementing data governance, or troubleshooting data issues.

Senior Data Engineer

Production-grade data engineering skill for building scalable, reliable data systems.

Table of Contents

  1. Trigger Phrases
  2. Quick Start
  3. Workflows
  4. Architecture Decision Framework
  5. Tech Stack
  6. Reference Documentation
  7. Troubleshooting

Trigger Phrases

Activate this skill when you see:

Pipeline Design:

  • "Design a data pipeline for..."
  • "Build an ETL/ELT process..."
  • "How should I ingest data from..."
  • "Set up data extraction from..."

Architecture:

  • "Should I use batch or streaming?"
  • "Lambda vs Kappa architecture"
  • "How to handle late-arriving data"
  • "Design a data lakehouse"

Data Modeling:

  • "Create a dimensional model..."
  • "Star schema vs snowflake"
  • "Implement slowly changing dimensions"
  • "Design a data vault"

Data Quality:

  • "Add data validation to..."
  • "Set up data quality checks"
  • "Monitor data freshness"
  • "Implement data contracts"

Performance:

  • "Optimize this Spark job"
  • "Query is running slow"
  • "Reduce pipeline execution time"
  • "Tune Airflow DAG"

Quick Start

Core Tools
# Generate pipeline orchestration config
python scripts/pipeline_orchestrator.py generate \
  --type airflow \
  --source postgres \
  --destination snowflake \
  --schedule "0 5 * * *"

# Validate data quality
python scripts/data_quality_validator.py validate \
  --input data/sales.parquet \
  --schema schemas/sales.json \
  --checks freshness,completeness,uniqueness

# Optimize ETL performance
python scripts/etl_performance_optimizer.py analyze \
  --query queries/daily_aggregation.sql \
  --engine spark \
  --recommend

Workflows

→ See references/workflows.md for details

Architecture Decision Framework

Use this framework to choose the right approach for your data pipeline.

Batch vs Streaming
Criteria Batch Streaming
Latency requirement Hours to days Seconds to minutes
Data volume Large historical datasets Continuous event streams
Processing complexity Complex transformations, ML Simple aggregations, filtering
Cost sensitivity More cost-effective Higher infrastructure cost
Error handling Easier to reprocess Requires careful design

Decision Tree:

Is real-time insight required?
├── Yes → Use streaming
│   └── Is exactly-once semantics needed?
│       ├── Yes → Kafka + Flink/Spark Structured Streaming
│       └── No → Kafka + consumer groups
└── No → Use batch
    └── Is data volume > 1TB daily?
        ├── Yes → Spark/Databricks
        └── No → dbt + warehouse compute
Lambda vs Kappa Architecture
Aspect Lambda Kappa
Complexity Two codebases (batch + stream) Single codebase
Maintenance Higher (sync batch/stream logic) Lower
Reprocessing Native batch layer Replay from source
Use case ML training + real-time serving Pure event-driven

When to choose Lambda:

  • Need to train ML models on historical data
  • Complex batch transformations not feasible in streaming
  • Existing batch infrastructure

When to choose Kappa:

  • Event-sourced architecture
  • All processing can be expressed as stream operations
  • Starting fresh without legacy systems
Data Warehouse vs Data Lakehouse
Feature Warehouse (Snowflake/BigQuery) Lakehouse (Delta/Iceberg)
Best for BI, SQL analytics ML, unstructured data
Storage cost Higher (proprietary format) Lower (open formats)
Flexibility Schema-on-write Schema-on-read
Performance Excellent for SQL Good, improving
Ecosystem Mature BI tools Growing ML tooling

Tech Stack

Category Technologies
Languages Python, SQL, Scala
Orchestration Airflow, Prefect, Dagster
Transformation dbt, Spark, Flink
Streaming Kafka, Kinesis, Pub/Sub
Storage S3, GCS, Delta Lake, Iceberg
Warehouses Snowflake, BigQuery, Redshift, Databricks
Quality Great Expectations, dbt tests, Monte Carlo
Monitoring Prometheus, Grafana, Datadog

Reference Documentation

1. Data Pipeline Architecture

See references/data_pipeline_architecture.md for:

  • Lambda vs Kappa architecture patterns
  • Batch processing with Spark and Airflow
  • Stream processing with Kafka and Flink
  • Exactly-once semantics implementation
  • Error handling and dead letter queues
2. Data Modeling Patterns

See references/data_modeling_patterns.md for:

  • Dimensional modeling (Star/Snowflake)
  • Slowly Changing Dimensions (SCD Types 1-6)
  • Data Vault modeling
  • dbt best practices
  • Partitioning and clustering
3. DataOps Best Practices

See references/dataops_best_practices.md for:

  • Data testing frameworks
  • Data contracts and schema validation
  • CI/CD for data pipelines
  • Observability and lineage
  • Incident response

Troubleshooting

→ See references/troubleshooting.md for details

1---
2name: "senior-data-engineer"
3description: Data engineering skill for building scalable data pipelines, ETL/ELT systems, and data infrastructure. Expertise in Python, SQL, Spark, Airflow, dbt, Kafka, and modern data stack. Includes data modeling, pipeline orchestration, data quality, and DataOps. Use when designing data architectures, building data pipelines, optimizing data workflows, implementing data governance, or troubleshooting data issues.
4---
5 
6# Senior Data Engineer
7 
8Production-grade data engineering skill for building scalable, reliable data systems.
9 
10## Table of Contents
11 
121. [Trigger Phrases](#trigger-phrases)
132. [Quick Start](#quick-start)
143. [Workflows](#workflows)
154. [Architecture Decision Framework](#architecture-decision-framework)
165. [Tech Stack](#tech-stack)
176. [Reference Documentation](#reference-documentation)
187. [Troubleshooting](#troubleshooting)
19 
20---
21 
22## Trigger Phrases
23 
24Activate this skill when you see:
25 
26**Pipeline Design:**
27- "Design a data pipeline for..."
28- "Build an ETL/ELT process..."
29- "How should I ingest data from..."
30- "Set up data extraction from..."
31 
32**Architecture:**
33- "Should I use batch or streaming?"
34- "Lambda vs Kappa architecture"
35- "How to handle late-arriving data"
36- "Design a data lakehouse"
37 
38**Data Modeling:**
39- "Create a dimensional model..."
40- "Star schema vs snowflake"
41- "Implement slowly changing dimensions"
42- "Design a data vault"
43 
44**Data Quality:**
45- "Add data validation to..."
46- "Set up data quality checks"
47- "Monitor data freshness"
48- "Implement data contracts"
49 
50**Performance:**
51- "Optimize this Spark job"
52- "Query is running slow"
53- "Reduce pipeline execution time"
54- "Tune Airflow DAG"
55 
56---
57 
58## Quick Start
59 
60### Core Tools
61 
62```bash
63# Generate pipeline orchestration config
64python scripts/pipeline_orchestrator.py generate \
65 --type airflow \
66 --source postgres \
67 --destination snowflake \
68 --schedule "0 5 * * *"
69 
70# Validate data quality
71python scripts/data_quality_validator.py validate \
72 --input data/sales.parquet \
73 --schema schemas/sales.json \
74 --checks freshness,completeness,uniqueness
75 
76# Optimize ETL performance
77python scripts/etl_performance_optimizer.py analyze \
78 --query queries/daily_aggregation.sql \
79 --engine spark \
80 --recommend
81```
82 
83---
84 
85## Workflows
86→ See references/workflows.md for details
87 
88## Architecture Decision Framework
89 
90Use this framework to choose the right approach for your data pipeline.
91 
92### Batch vs Streaming
93 
94| Criteria | Batch | Streaming |
95|----------|-------|-----------|
96| **Latency requirement** | Hours to days | Seconds to minutes |
97| **Data volume** | Large historical datasets | Continuous event streams |
98| **Processing complexity** | Complex transformations, ML | Simple aggregations, filtering |
99| **Cost sensitivity** | More cost-effective | Higher infrastructure cost |
100| **Error handling** | Easier to reprocess | Requires careful design |
101 
102**Decision Tree:**
103```
104Is real-time insight required?
105├── Yes → Use streaming
106│ └── Is exactly-once semantics needed?
107│ ├── Yes → Kafka + Flink/Spark Structured Streaming
108│ └── No → Kafka + consumer groups
109└── No → Use batch
110 └── Is data volume > 1TB daily?
111 ├── Yes → Spark/Databricks
112 └── No → dbt + warehouse compute
113```
114 
115### Lambda vs Kappa Architecture
116 
117| Aspect | Lambda | Kappa |
118|--------|--------|-------|
119| **Complexity** | Two codebases (batch + stream) | Single codebase |
120| **Maintenance** | Higher (sync batch/stream logic) | Lower |
121| **Reprocessing** | Native batch layer | Replay from source |
122| **Use case** | ML training + real-time serving | Pure event-driven |
123 
124**When to choose Lambda:**
125- Need to train ML models on historical data
126- Complex batch transformations not feasible in streaming
127- Existing batch infrastructure
128 
129**When to choose Kappa:**
130- Event-sourced architecture
131- All processing can be expressed as stream operations
132- Starting fresh without legacy systems
133 
134### Data Warehouse vs Data Lakehouse
135 
136| Feature | Warehouse (Snowflake/BigQuery) | Lakehouse (Delta/Iceberg) |
137|---------|-------------------------------|---------------------------|
138| **Best for** | BI, SQL analytics | ML, unstructured data |
139| **Storage cost** | Higher (proprietary format) | Lower (open formats) |
140| **Flexibility** | Schema-on-write | Schema-on-read |
141| **Performance** | Excellent for SQL | Good, improving |
142| **Ecosystem** | Mature BI tools | Growing ML tooling |
143 
144---
145 
146## Tech Stack
147 
148| Category | Technologies |
149|----------|--------------|
150| **Languages** | Python, SQL, Scala |
151| **Orchestration** | Airflow, Prefect, Dagster |
152| **Transformation** | dbt, Spark, Flink |
153| **Streaming** | Kafka, Kinesis, Pub/Sub |
154| **Storage** | S3, GCS, Delta Lake, Iceberg |
155| **Warehouses** | Snowflake, BigQuery, Redshift, Databricks |
156| **Quality** | Great Expectations, dbt tests, Monte Carlo |
157| **Monitoring** | Prometheus, Grafana, Datadog |
158 
159---
160 
161## Reference Documentation
162 
163### 1. Data Pipeline Architecture
164See `references/data_pipeline_architecture.md` for:
165- Lambda vs Kappa architecture patterns
166- Batch processing with Spark and Airflow
167- Stream processing with Kafka and Flink
168- Exactly-once semantics implementation
169- Error handling and dead letter queues
170 
171### 2. Data Modeling Patterns
172See `references/data_modeling_patterns.md` for:
173- Dimensional modeling (Star/Snowflake)
174- Slowly Changing Dimensions (SCD Types 1-6)
175- Data Vault modeling
176- dbt best practices
177- Partitioning and clustering
178 
179### 3. DataOps Best Practices
180See `references/dataops_best_practices.md` for:
181- Data testing frameworks
182- Data contracts and schema validation
183- CI/CD for data pipelines
184- Observability and lineage
185- Incident response
186 
187---
188 
189## Troubleshooting
190→ See references/troubleshooting.md for details
191 
192 

Discussion

Alternatives

Also in Data pipelinesSee all 533 in Development →