The Modern Engineer Playbook

• 6 in-depth modules (Design, Setup, Build, Automate, Maintain, Migrate)
• 87 video training lessons 
• Hands-on experience with modern tools (Airbyte, Fivetran, dbt, PostgreSQL, Snowflake, GitHub, Metabase, Tableau & Docker)
• Ongoing support from Michael & other students
• Bonus: Access to private data sources (PostgreSQL & GSheets)
• Bonus: Workflow Automation Scripts (x3)
• Bonus: Data Architecture Handbook
• Bonus: Architecture Design Templates
• Bonus: The "Simple Stack" Checklist 

PS - I recommend watching the video at the top of this page to get more details. You'll see exactly what the course looks like as a student, what we'll build & a lot more. 

Step 1: Design

Learn how to design a simple, yet modern end-to-end pipeline

The first step is to establish a clear understanding of common design patterns so you can feel confident picking a strategy or learning a tool.

Without a strategy, you may look busy but will feel completely overwhelmed.

But with one, you’ll have more clarity & your efforts will have more productive, compounding results.

Step 2: Setup

Gain hands-on experience setting up common data tools

With our design in hand, we'll then configure each core component of the data stack, establish roles/permissions where needed & ensure connectivity between them.

You'll learn how to setup & use tools such as: Postgres, Airbyte, dbt, Metabase, GitHub & Docker.

Step 3: Build

Confidently build a data architecture from scratch with best practices

In this step, we'll implement a single foundational end-to-end data pipeline that touches all 5 core components and establish Production vs Development environments.

This sets the standards & conventions for which all future work on the architecture will follow.

By keeping the scope small, you’re able to pay close attention to each layer while also showcasing quick wins.

(Yes, we'll cover data modeling too)

Step 4: Automate

Discover how to automate your development workflow

Next, it's time to create automated workflows that validate data quality before reaching Production & ensure our data models stay updated each day.

Automation makes the development cycle more efficient, reduces egos/emotions in code reviews & overall provides more control over the architecture. 

Once you get this right, it's hard to work on any other team without it in place.

Step 5: Maintain

Learn how to maintain & scale your architecture long-term

Lastly, we'll create assets that provide transparency into the design, organize important information & overall establish a culture of high quality development long-term.

The biggest cost in any architecture is maintenance, which compounds over time.

Being proactive will save countless hours later while enabling developers to have fun creating new features vs troubleshooting.

Step 6: Migrate (BONUS)

Migrate from a self-hosted stack to a "Production-Ready" cloud setup

Open source & self-hosted stacks are excellent for learning & gaining experience. 

But most Production-ready data stacks won’t be designed on Codespaces or a single virtual machine.

In this section, you'll learn how to setup & use new tools such as: Snowflake, Fivetran & Tableau.

Resources (BONUS)

Access custom resources to prepare you for real implementations

As a student, you'll also get access to tons of resources to help you implement your Simple Stack faster & maintain it more effectively:

This includes (but not limited to):

• A Simple Stack Checklist (Excel)
• Pre-made workflow automation jobs (yaml)
• Pre-written documentation, style guides & more
• Data Architecture designs

Each of these are based on real-world implementations & will save you a ton of time!

We'll cover key topics data engineers & team leaders need to understand such as:

• How to think strategically about designing an end-to-end architecture that's simple & easy to follow
• How to create a foundational data model (facts & dimensions) so you can build pipelines with a clear strategy
• How to properly set database roles & permissions so you stay in control of user access
• How to automate testing & deployments so you can spend more time on development
• Best practices & tips from 10 years as a developer, consultant & educator so you avoid common mistakes 

In my experience, the best engineers are the ones that see the bigger picture of their work, not just the individual task.

And my goal with this course is to help you start approaching data like an architect, not just another developer.

Imagine walking into your office, opening up your laptop and instead of feeling like you're treading water, you feel like you're solving a fun puzzle.

As a beginner, your focus is often on coding or individual tasks. But in my experience, the top performers approach it more abstractly (like a mental puzzle).

And with the right understanding you too can start to think higher level.

By learning & applying the information in this course, you will:

• Feel less pressure to learn every tool or skill (you'll instead be able to think through scenarios and adapt)
• Become the go-to person on your team & have teammates wondering how you know so much
• Be able to outline any architecture in a few minutes
• Complete tasks much faster than others (work smarter, not harder)
• Identify design optimization opportunities & propose solutions
• Build your own stack from scratch
• Fast-track your career growth by learning to contribute at a higher-level, without wasting precious time trying to do it all alone

Stack 1: Self-Hosted Tools 

The main portion of the course is focused on using all open-source, self-hosted tools. 

This avoids the need to create multiple accounts & keeps the experience consistent for everyone.

For this, we will create an end-to-end data playground using the following tools:

• Local Development - GitHub Codespaces
• Database - Postgresql
• Ingestion - Airbyte
• Transformation - dbt Core
• Version Control & CI/CD - GitHub
• Reporting - Metabase

Stack 2: Cloud-Based Tools 

In the Migrate section, we'll look at translating the fully self-hosed stack to a fully Cloud-based setup.

This is more reflective of a common "real-world" production setup and is intended to give you exposure to common options.

In this section, we'll use the following tools:

• Local Development - N/A
• Database - Snowflake
• Ingestion - Fivetran
• Transformation - dbt Cloud
• Version Control & CI/CD - GitHub
• Reporting - Tableau

Note: The intention here is not to say these are the BEST tools or the ones that you should use. That is highly dependent on your scenario (as discussed more in the course). 

Like many others, I started my data career using drag-and-drop tools and traditional databases.

Then I joined a team using dbt, Snowflake and GitHub and felt overwhelmed with how to actually use it. It was all so different.

Fast-forward to today and I now help Fortune 100 companies to greenfield startups implement data architectures with modern workflows and cloud databases. 

I'm both a Microsoft & dbt Certified Developer and have taught 3+ million aspiring engineers through my YouTube Channel (@KahanDataSolutions).

But this took years of practice, trial and error and learning on the job.

This course not only teaches you step-by-step how to implement a data architecture from scratch, but shares tips, tricks and lessons based on my real-life experience as a data consultant.

You'll fast-track your learning, avoid common mistakes, and feel confident contributing to any project.

I hope to see you in the course!

While orchestration is an important topic, this course does not go overly deep into it.

In my opinion, dedicated orchestration tools (ex. Airflow, Prefect, Dagster, etc.) are excellent, but also not necessary when first getting started.

They are components to be added later after you've set strong foundations of your initial end-to-end stack.

In this course, we will still establish baseline orchestration via GitHub Actions (& later dbt Cloud) as daily cron jobs.

This is sufficient to keep the initial data models refreshed each day & is an approach I often use with real client implementations. 

Having said that, your playground stack is just that - it's yours!

I encourage you to take what we build in the course and continuously add to it.

This includes introducing dedicated orchestration tools (or anything else you can think of).

This course will not cover how to manage cloud computing for big data or administering cloud providers (ex. AWS, Azure, GCP).

It also does not touch on AI or Machine Learning.

I also personally do not have experience in the field of Machine Learning/AI and therefore would not be the right person to teach you about it. 

These are all worthy topics that could have entire courses dedicated to them, but are outside the scope of this particular course.

Instead, the focus is setting the foundations of an end-to-end stack for internal analytics using common tools & workflows. 

To see the specific tools used in this course, please refer to the "What tools will we be using?" question.

The entire course material spans roughly ~7.5 hours.

But you should expect it to take a bit longer since you are here to learn & not rush through it.

I recommend you have a have a solid baseline understanding of SQL, Git & general database design (schemas, tables, etc.).

Generally speaking, this is intended for more senior-level engineers.

However, more junior-level engineers are welcome to join if they have some experience under their belt.

Note: This course is focused on architecture & overall workflow and should not be considered a bootcamp style training on individual skills or tools.

In short, no.

The data will be a very small amount stored across two sources:

1. PostgreSQL database 
2. Google Sheets

Both sources are managed outside of the course but access is given to each student to load it into their own environment.

Why not "big data"? 

I don't believe having more data helps to better understand the concepts.

If anything, it makes it messier and distracts from the material.

But you can still scale it up

By the end of the course, you'll have created your very own playground stack where, on your own, you can:

• Add more/bigger data sources
• Add streaming
• Add whatever you want

It's your own personal playground and the sky is the limit. 

Absolutely - Although I recommend adding your own unique touch to your stack by adding new data sources, data models, reporting, etc.

Otherwise it'll look too generic.

You can certainly mimic the stack we'll create at your company. In fact, it's very similar to one's I've done myself.

However, the open-source Playground Stack we create in the initial Setup section will be hosted on GitHub Codespaces which is not intended for Production situations.

Rather, it's intended for development environments.

Therefore, you should not use this directly for your company, but rather use it as an example.

In the Migrate section we will move to an all-cloud, "production-ready" setup. 

This is definitely a more realistic stack for you to implement at a company.

However, as mentioned in the course, the tools used are simply for example purposes and do not necessarily mean they are the "best" options for you.

There are a TON of great data architecture videos on YouTube created by both myself and other content creators. 

While you can learn pretty much anything from YouTube, you are going to spend significantly more time trying to put all the pieces together on your own.

Not to mention you may not be learning in the right order.

This course will give you a step-by-step guided path for building data architectures in a tested way.

You'll also get access to pre-created resources, pre-created data sources & myself along the way.

In short, you will learn more in less time and in the right order.

All course material is hosted on my website (KahanDataSolutions.com).

Once you enroll, you will be prompted to create a username/password which you will use to log in anytime.

Note: Once purchased, you will have instant access to all material & lifetime access to all future updates. There have already been a few updates since the original release.

This course comes with is a 30 day money back guarantee.

This means if you enroll & quickly realize it's not the right fit for you, you can request a refund & get 100% of your money back.