Program Setup & Workflow

W1: Program Setup & Workflow

What you’re doing this week

You’re not “learning”. You’re building the machine that will make you learn and ship for the next 12 months.

If you skip this week, the rest becomes chaos: random notes, half-finished repos, no proof of work, zero momentum. So we set the system once and then just execute.

Time: 4–6 hours
Output: a clean workspace + GitHub structure + weekly routine + “definition of done”

The promise (what you’ll have by the end)

By the end of W1 you will have:

• A simple workspace you won’t hate (folders, naming, where stuff lives)
• A portfolio skeleton on GitHub (so every next module becomes “add one more brick”)
• A weekly cadence that is actually doable while you work in AMS
• A quality bar (“done means done”) so you don’t ship junk
• A tracking sheet (or a tiny markdown file) so you see progress in black and white

The workflow (your weekly loop)

This is the loop you’ll repeat every week:

Pick one deliverable. Define what “done” looks like.

1. Plan (20–30 min)

Make it work. Don’t polish. Don’t overthink.

1. Build (2–4 hours)

Write what you did, how to run it, what broke, what you learned.

1. Document (30–45 min)

Push to GitHub. Update the landing/module page. Ship a tiny post (optional but powerful).

1. Publish (15–30 min)

That’s it. No hero mode.

Setup checklist (do this in order)

1) Create your “home base” folder

On your laptop create one folder. Example:

/work/sap-ai-program/

Inside:

• /projects/ (code)
• /notes/ (markdown notes)
• /assets/ (diagrams/screenshots)
• /data/ (samples, anonymized)

Rule: if it doesn’t fit here — it doesn’t exist.

2) Create (or prepare) 3 repos on GitHub

You will build 3 real projects. Create empty repos now:

1. sap-ai-ticket-analyzer
2. sap-data-pipeline
3. sap-ops-rag-kb

Add a simple README to each with:

• one-line purpose
• current status: “Week 1: setup”
• how you plan to use it later

Don’t write novels. Just start.

3) Add a “program repo” (optional but recommended)

Create one more repo:

program-notes (or sap-ai-course-notes)

It will store:

• weekly module notes
• decisions
• links
• progress tracker

This repo becomes your memory + proof of work.

4) Create your weekly tracker (minimal)

Create a file progress.md (or a Google Sheet if you prefer).

Example format:

• W1: Setup & Workflow — ✅ done (date)
• deliverable: repos + folder structure + cadence
• time spent: 5h
• 3 wins:
• 1 problem:
• next step:

Simple beats fancy.

5) Define “done” (your quality bar)

For this program, “done” means:

• ✅ The deliverable exists in a repo (not on your desktop)
• ✅ README has “How to run” or “What this is” (even if tiny)
• ✅ There is at least one screenshot / diagram / example input-output
• ✅ You wrote a short “What I learned / What I’ll improve” note

If one of these is missing — it’s not done. Period.

Deliverables for W1 (you must ship these)

Deliverable A — Workspace created

• The folder structure exists
• You can point to it and say “this is where the program lives”

Deliverable B — GitHub repos created

• 3 project repos exist + basic README
• 1 notes repo exists (optional but recommended)

Deliverable C — Weekly cadence written down

Write a short routine in program-notes/W1.md:

• Which day is “Plan day”
• Which day is “Build day”
• Which day is “Publish day”
• Minimum weekly hours: 4–6

Make it realistic. If you lie to yourself here, you will quit later.

Common traps (don’t do this)

No. One folder + markdown is enough.

• Trap 1: “I’ll set up Notion / Obsidian / perfect system first.”

You will read forever. Ship first.

• Trap 2: “I’ll start coding after I read more.”

Pretty is a reward after consistency.

• Trap 3: “I’ll make it pretty.”

Quick self-check (2 minutes)

Answer yes/no:

• Do I have one place where everything lives?
• Can I show 3 repos on GitHub right now?
• Do I have a weekly routine I can actually follow?
• Do I know what “done” means?

If any “no” — fix it this week.

Next module preview (W2–W3)

Next you’ll build the simplest backend skeleton:
Python + FastAPI, config, logging, and one endpoint.
Not fancy. Just real.