Maia Enablement - Maximising Your Productivity Using Maia Team Getting Started
Welcome to the Maia Enablement Workshop! This a Hands-on workshop (~1.5 hrs) — Meet the world's first agentic AI for data teams, and put it to work.
Maia rethinks manual data work. It autonomously creates, manages, and evolves data pipelines — so you can stop maintaining and start doing the work that actually matters. Think of it as an always-on AI data team at your fingertips.
Maia setup + productivity checklist, ideally on your own project
Discover standards, consolidate best practices
Total: ~63 minutes (~1 hour)
Mission Control is used throughout the workshop. See Mission-Control-Reference.md for a full guide.
Resources
Supporting materials available in enablement/resources/:
maia-phrasebook.md — Slash commands, useful phrases, and power user tips for every stage of working with Maia
context-file-examples/ — Example prompts and ready-made context files for different personas
Quick Reference: What They Learn
1Activity 1: Build Your First Pipeline in Mission Control
Conversational AI - simple prompts work
Maia asks clarifying questions
Mission Control workflow — delegate and review
Run multiple tasks in parallel
Quick results - minutes not hours
2Activity 2: Create Your Own Context File
Define standards once, apply automatically
Same request, different output
Scale to customer standards
3Activity 3: Pipeline Doctor
Maia knows what file you’re viewing
Identifies antipatterns and technical debt
Actionable recommendations
Run separate analyses as parallel tasks
4Activity 4: Real-World Challenge
Build complex pipelines confidently
Apply all techniques together
Recognize customer patterns
Run two builds side by side
5Activity 5: Enterprise Scale Operations
Mass updates across multiple pipelines
Batch execution and monitoring
Data quality auditing at scale
Operational intelligence and summaries
6Activity 6: Building Maia Skills
Understand skills vs context files
Create reusable task-specific instructions
Build skills for common patterns (incremental load, data quality, error handling)
Combine skills + context files for full customization
7Activity 7: Maximising Your Productivity with Maia
Reverse engineer standards from existing pipelines
Codify implicit knowledge into context files
Create navigable documentation structure
Consolidated productivity checklist across all activities
Identify gaps and confirm readiness
Apply the setup to your own project
1Activity 1
Build Your First Pipeline in Mission Control
Time:
6 minutes
What You’ll Learn:
How to communicate with Maia to build a basic pipeline
Tip: Type “start workshop” in Maia chat to be guided through each activity step by step!
Instructions
Open Mission Control from the left navigation bar
Click the AI Agents icon in the left navigation, then click Mission Control.
Pick 2 to 4 scenarios below
Copy each prompt (use the Copy button on each scenario card)
Create a separate task in Mission Control for each scenario — paste each prompt as its own task description
Click the Add drop-down, then click Add task. The New task dialog opens.
Project
Select the workshop project. It's the same one you opened in Getting Started, Step 2.
Branch
Select the branch that matches your assigned number (e.g., Maia Workshop 8). Never pick someone else's branch.
Create new branch
Uncheck this box. Maia then builds directly in your branch, so your pipeline is there for Activity 2 onwards. If it's left checked, Maia works in a separate task branch that you'd have to merge yourself.
Environment
Select the workshop environment. This is the Snowflake connection Maia uses to load and query data.
Priority
Leave as Medium.
Label optional
Leave blank. Out of scope for this workshop.
Knowledge graph optional
Leave blank. Out of scope for this workshop. You'll learn about the Context Engine in Activity 7.
Prompt
Paste one scenario prompt here. Leave Mode: Act and Ask permission on their defaults so Maia checks with you before it runs anything.
Then click Start task. Repeat for each scenario you picked, one task per scenario.
Start task vs Create:Create only adds the task to the backlog. Click Start task so Maia begins work right away.
Let Maia build your pipelines in parallel!
Each task moves to In progress. Click it to open the chat panel and watch Maia work.
If the task moves to Needs your attention, Maia has a question or wants permission. Click the task and reply in the chat.
To see the pipeline, click the task, then click Open in Designer (or Review in Designer if it needs your attention).
When you're happy with the result, ask Maia to commit and push your changes, then click Move to completed.
Why multiple tasks? Running scenarios as parallel tasks is a great way to see how Mission Control handles concurrent work!
Important: Don’t create a new branch — just work on the same branch for simplicity during the workshop.
Key Learnings
Conversational AI: Maia asks clarifying questions - you don’t need every detail upfront
Natural Language: Simple prompts work - no technical syntax needed
Quick Results: From idea to working pipeline in minutes
Component Variety: Maia selects appropriate components based on your requirements
Not sure how to phrase your prompt? See enablement/resources/maia-phrasebook.md for useful commands and phrases.
Choose Your Scenario
1
Daily Sales Data Load
Our sales team exports daily transactions as sales_transactions.csv into a Snowflake internal stage. Create a pipeline to load this into a Snowflake table so we can report on daily revenue. Enable Force Load.
2
Customer Data Load
Our CRM exports customer data as customers.csv into a Snowflake internal stage every night. Create a pipeline to load this into a Snowflake table for the analytics team. Enable Force Load.
3
Product Catalog Load
The product team updates our catalog weekly as products.csv in a Snowflake internal stage. Create a pipeline to load this into a Snowflake table, replacing it each time. Enable Force Load.
4
Multi-Table Load
We receive orders.csv and territories.csv in a Snowflake internal stage. Create a pipeline to load both — territories first since orders depend on territory data. Enable Force Load.
5
Sales Territory Analytics
Management wants a territory performance report. Create a transformation pipeline that joins sales transactions with territories, calculates total sales by territory, and outputs to a Snowflake table.
Not sure which to pick? Quickest: Scenario 2. Most realistic: Scenario 4.
Let Maia ask you for details! You don’t need to provide everything upfront.
Explore what Maia built: Open the pipeline in Designer and click through the components on the canvas — see how Maia structured it and what components it chose.
Don’t forget: When Maia finishes building, ask it to commit and push your changes!
Stretch Goals (If Time)
Ask Maia to add audit/metadata columns
Ask for error handling
Try a second scenario
2Activity 2
Create Your Own Context File
Time:
7 minutes
What You’ll Learn:
How to define project standards using context files
What You’ll Do
Ask Maia to create a context file with your project rules (2 min)
Rebuild your Activity 1 pipeline (3 min)
Compare before/after - same scenario, different output! (2 min)
Key Learnings
Context Files = Standards: Define your rules once, Maia applies them automatically
Automatic Application: Context files work silently - no need to repeat rules
Visible Impact: Same request, different output (notes, naming, components)
Customer Value: Scale this to enforce customer standards across all pipelines
Step 1: Create Your Context File (2 min)
Mission Control tip: Just create the context file on one of your existing tasks — since you're all on the same branch, it will apply everywhere.
Copy this prompt (update the table prefix to your own name):
Create a context file in the default location.
Business context: We are a [brief description, e.g. “retail company processing daily sales data”]
Rules:
Add a summary note onto the canvas of all pipelines
Prefer specialized components over SQL script components
Follow a clear naming standard for pipelines and tables
All table names should be prefixed with [YOUR_NAME] in uppercase with underscores
Note: Context files live in the git repo and apply to everyone on the branch — they’re project standards, not personal preferences. We use a name prefix here so trainees don’t conflict in the shared schema.
You inherit a legacy pipeline with performance issues. You’ll let Maia diagnose the problems, improve it, and then protect it with a test.
Step 1: Open & Analyze (5 min)
There are two problematic pipelines to analyze — do both! Open each in Designer and run them as separate Mission Control tasks (you can reuse existing tasks):
Review each briefly — notice all the SQL scripts. Then ask Maia:
Review this pipeline and identify optimization opportunities. Focus on: performance, component choices, and design patterns.
You don’t need to tell Maia which file you’re looking at — it already knows!
Maia will analyze the pipeline and present its findings. Study what it found — SQL overuse, performance bottlenecks, missed parallelization, better component alternatives.
When Maia offers to implement the improvements, say yes! Let it create an improved version.
Step 2: Compare Before & After (2 min)
Open both the original and improved pipelines side by side. Notice:
Create a transformation pipeline that combines ORDERS, CUSTOMERS, and PRODUCTS tables, calculates customer lifetime value, identifies top 10 customers, and flags at-risk customers (no orders in 90 days).
Prompt:
Create a pipeline called “customer_analytics” that analyzes customer purchasing patterns.
I need to:
Combine data from ORDERS, CUSTOMERS, and PRODUCTS tables
Calculate total revenue per customer and their order count
Identify our top 10 highest-revenue customers
Flag customers who haven’t ordered in 90+ days as “at risk”
Calculate each customer’s average order value
Output the results to a table called CUSTOMER_ANALYTICS
All source tables are in the default database and schema.
2
Scenario 2: Medallion Architecture Pipeline
Business context:
Enterprise modernizing data platform — messy data lake with no clear layers.
Your mission:
Create an orchestration pipeline implementing Bronze (raw) → Silver (cleaned) → Gold (aggregated) layers for sales data.
Prompt:
Create a medallion architecture pipeline called “medallion_sales_pipeline” with three layers:
BRONZE LAYER:
I have raw sales data in BRONZE_SALES_RAW table that needs cleaning
It has: sale_id, customer_id, product_id, sale_date, amount, region
The data has duplicates and some null values
SILVER LAYER:
Clean the bronze data by removing duplicates (based on sale_id)
Filter out records with null amounts
Output to SILVER_SALES_CLEAN
GOLD LAYER:
Create daily sales aggregations from the clean data
Show total sales, number of transactions, and average order value by date
Output to GOLD_SALES_DAILY
The pipeline should run these three layers in sequence.
3
Scenario 3: Data Quality Guardian Pipeline
Business context:
Financial services company with bad data causing reporting errors and compliance risks.
Your mission:
Create a transformation pipeline that validates, cleanses, and separates clean vs. problematic customer records.
Prompt:
Create a pipeline called “data_quality_guardian” to validate and clean customer data.
Source: RAW_CUSTOMERS table with these quality issues:
Some records have null customer_id or email
Emails don’t always have @ symbols
Phone numbers have inconsistent formats (should be 10 digits)
Some signup dates are in the future (impossible)
Credit scores should be between 300-850
Status should be ‘active’, ‘inactive’, or ‘suspended’
I need to:
Validate all these rules
Use the Data Cleanse component to clean the data (trim whitespace, lowercase emails, standardize phones)
Separate clean records from rejected ones
Send clean records to CUSTOMERS_CLEAN table
Send rejected records to CUSTOMERS_REJECTED table with a reason why they failed
Tip: Ask Maia to use the Data Cleanse component for standardization tasks.
4
Scenario 4: Slowly Changing Dimensions (SCD Type 2)
Business context:
Data warehouse needs to track historical changes to customer data over time.
Your mission:
Create a pipeline implementing SCD Type 2 logic — detecting changes, expiring old records, and inserting new versions with history tracking.
Prompt:
Create a pipeline called “customer_scd_type2” to track customer changes over time.
I have:
STAGING_CUSTOMERS: New and updated customer records
Standardize 4 pre-built pipelines with consistent error handling, naming, and metadata.
We’ve provided intentionally inconsistent HR/Finance pipelines in enablement/sample-pipelines/activity-5-pipelines/ — open them to see the mess!
Prompt:
I need to standardize the 4 orchestration pipelines in enablement/sample-pipelines/activity-5-pipelines/.
For each pipeline, please:
Add a clear description
Standardize all component names to be clear and consistent
Add success/failure transitions where missing
Let’s start with employee_sync.orch.yaml, then apply the same pattern to the others.
2
Scenario 2: Batch Pipeline Execution & Monitoring
Goal:
Create a master orchestration pipeline that coordinates multiple child pipelines with parallel execution, dependency management, and failure handling.
Prompt:
Create a master orchestration pipeline that runs all the pipelines in enablement/sample-pipelines/activity-5-pipelines/.
Run all orchestration pipelines in parallel first, then run all transformation pipelines after they complete.
3
Scenario 3: Cross-Pipeline Refactor
Goal:
Apply a consistent change across all pipelines in one go — the kind of task that normally takes hours.
Prompt:
Add a consistent logging pattern to every orchestration pipeline in enablement/sample-pipelines/activity-5-pipelines/.
Each pipeline should log the pipeline name and a timestamp at the start and end of execution.
4
Scenario 4: Legacy Modernization at Scale
Goal:
Convert SQL-heavy pipelines to use specialized components.
Prompt:
Review all the orchestration pipelines in enablement/sample-pipelines/activity-5-pipelines/ and create a modernization plan:
What does each SQL block do?
Which specialized components should replace each SQL block?
What are the benefits of conversion?
Don’t rebuild yet - just give me the plan.
Then:
Now implement the modernization plan.
Key Takeaways
Same conversation patterns work for 1 or 100 pipelines
Maia goes beyond building — into monitoring and managing
Tasks that took days now take minutes
6Activity 6
Building Maia Skills
Turn Your Pipeline Into Reusable Knowledge
Time:
6 minutes
What You’ll Learn:
How to create skills that teach Maia repeatable patterns
Key Learnings
By the end of this activity, you should understand:
Skills vs Context Files: When to use each and how they differ
Skill Structure: The anatomy of a SKILL.md file
Activation Patterns: How skills are triggered and used
Practical Skills: Build skills that solve real problems
Skill Libraries: How to organize and maintain skills for teams
Skills vs Context Files
You already know context files — they’re always-on preferences and standards.
Skills are different:
Activated on-demand when Maia recognises a relevant task
Define specific, repeatable tasks with step-by-step instructions
Live in .matillion/maia/skills/<skill-name>/
Context Files:Always loaded. Standards, naming, preferences.Example: “Prefix tables with ACME_”
Skills:Activated when relevant. Specific repeatable tasks, step-by-step procedures.Example: “How to build incremental loads”
Rule of thumb: If you’d explain it in one sentence, it’s a context file. If you’d need to walk someone through it, it’s a skill.
Your Mission
Take the pipeline you built in Activity 4 and turn it into a skill.
The goal: if someone asks Maia to build a similar pipeline in the future, Maia should follow the same pattern you used — without being told the details every time.
Step 1: Create the Skill (5 min)
Tell Maia something like:
Take my pipeline from Activity 4 and create a skill from it. The skill should:
Have a SKILL.md with instructions explaining the pattern generically (not tied to specific tables)
Include a sample pipeline file (.orch.yaml or .tran.yaml) as a working example — NOT embedded DPL code inside the markdown
The skill folder should contain both files, e.g.: .matillion/maia/skills/my-skill/SKILL.md .matillion/maia/skills/my-skill/example-pipeline.orch.yaml
Step 2: Peek at What Maia Created (1 min)
Open the skill folder and check two things:
SKILL.md — Does it describe the pattern generically, not just the specific tables you used? Is the description broad enough to trigger on similar requests?
Sample pipeline file — Is there an actual .orch.yaml or .tran.yaml file alongside the SKILL.md? Open it in Designer to confirm it’s a valid, working pipeline.
Common gotcha: Maia sometimes embeds DPL code as a YAML block inside the SKILL.md instead of creating a separate pipeline file. If this happens, ask Maia:
Move the example pipeline out of the SKILL.md into its own .orch.yaml file in the same skill folder.
Step 3: Test It (5 min)
Ask Maia to build a different pipeline that should trigger your new skill. For example:
Built data quality for CUSTOMERS?
Ask for data quality on ORDERS
Built a medallion pipeline for sales?
Ask for one for inventory
Built an incremental load?
Ask for one on a different table
Did the skill activate? Did Maia follow the pattern?
Didn’t Finish Activity 4?
No problem — just ask Maia to create a skill for a pattern you use often in your work. Some ideas:
Incremental loadingError handling in orchestrationsData quality validationSCD Type 2
Discussion
When would you use a skill vs a context file for a customer?
What patterns do you explain to Maia repeatedly? (Those are skills waiting to happen.)
How would a team maintain a shared skill library?
Key Takeaways
Skills define specific, repeatable tasks that Maia activates on-demand
Context files encode standards that always apply
You don’t need to hand-craft skill files — Maia builds them for you
The value is in testing that the skill activates and produces consistent results
Bring together everything you’ve learned into a clear, actionable framework for getting the most out of Maia
Best done on your own project! This activity is most valuable when run against a real project with your team’s pipelines and standards. If you don’t have one available, you can still complete it here in the workshop project.
The Five Pillars of Maia Productivity
Throughout this workshop you’ve learned many techniques. They all come down to five things:
Pillar
What It Does
Key Actions
1. Context Files
Tell Maia WHO you are and WHAT standards to follow
Rules folder, examples, manual upload
2. Skills
Tell Maia HOW to do repeated tasks YOUR way
Create skill files, combine with context
3. Context Engine
Give Maia deep knowledge about YOUR data
Knowledge Graphs, crawlers, metadata
4. Process
Work WITH Maia effectively
Clear prompts, let Maia ask, review output
5. Mission Control
Delegate to Maia async and at scale
Async tasks, branch per task, concurrent work
The more you invest in pillars 1–3, the less effort pillars 4 and 5 require.
Setting Up for Maximum Productivity
These three steps are the actionable setup — do these when adopting Maia in any project or environment.
1
Step 1
Discover Your Standards
The first thing to do is let Maia discover what standards already exist in your project. This single prompt sets up your rules folder, context files, and documentation in one go.
Copy and paste this prompt into Maia:
I need you to review all the pipelines within this project. Your goal is to identify our internal standards, specifically:
How we build pipelines
Our best practice naming conventions
Pipeline building standards
Documentation practices
After your review, please perform the following actions:
Create a new file named `README.md` inside the `.matillion/maia/rules` folder.
Create a new folder named `docs` at the project’s root level.
In the `docs` folder, generate context files based on the standards you’ve identified.
In the README.md, provide a clear directory linking to all context files.
Build a navigable README so everything is discoverable
Why this matters: You don’t have to document standards from scratch — Maia extracts them from your existing work.
2
Step 2
Build Skills for Repeatable Patterns
Now let Maia identify your team’s repeatable workflows and turn them into skills automatically.
Copy and paste this prompt into Maia:
Review the pipelines in this project and identify any repeatable patterns or common workflows — things like:
Data loading patterns (full load, incremental, CDC)
Error handling approaches
Data quality checks
Standard pipeline structures that get reused
For each pattern you find, create a Maia skill in `.matillion/maia/skills/`. Each skill should have:
A SKILL.md file with name and description frontmatter, and clear step-by-step instructions
A sample pipeline file (.orch.yaml or .tran.yaml) as a working example — NOT embedded DPL code inside the SKILL.md
Common gotcha: Maia sometimes embeds DPL as a YAML block inside the SKILL.md instead of creating a separate pipeline file. If this happens, ask:
Move the example pipelines out of the SKILL.md files into their own .orch.yaml or .tran.yaml files in the same skill folder.
What Maia will do:
Analyze pipelines for recurring patterns
Create a skill folder for each pattern found
Write SKILL.md files with frontmatter so they’re auto-discoverable
Include step-by-step instructions Maia can follow
Context files + Skills together: Context defines what standards to follow. Skills define how to execute common tasks. Together, they make Maia work the way your team works.
3
Step 3
Connect the Context Engine
Context files and skills tell Maia your standards. The Context Engine gives Maia deep knowledge of your actual data.
Knowledge Graphs — connect to your data warehouse and crawl table structures, column metadata, and relationships automatically
Semantic Learning — Maia learns from your chat history and enriches its understanding with business terminology and data semantics
Metadata Matters — column descriptions, tags, and comments in your warehouse help Maia understand what your data actually means
How to set up:
An Admin creates a Knowledge Graph in the Context Engine dashboard
Add a crawler pointing to your warehouse — it runs on a schedule to stay current
Select the Knowledge Graph when chatting with Maia or creating Mission Control tasks
Why this matters: Without the Context Engine, Maia knows your standards but has to discover your data every time. With it, Maia already knows your tables, columns, and relationships — so it builds pipelines faster and more accurately.
Your Readiness Checklist
Before you leave, confirm you can tick off each area:
1. Context Files
2. Skills
3. Context Engine
4. Working with Maia
5. Mission Control
Key Takeaway
The more context you give Maia, the better it performs.
Set up your context files and skills once — every interaction after that is faster, more consistent, and more aligned with your standards.
This is the framework for Maia adoption. Context, skills, process — set these up and productivity follows.
