Jump to bottom ↓

CCA-F Curriculum — Development Environment Setup Guide

Complete before starting Module 0 Week P1

Reference material — not tracked by the progress dashboard (not week-structured). Complete this guide before starting Module 0, Week P1.

Section 1 — AWS Account Setup (complete first — can take time to verify)

Start with AWS because it occasionally requires identity verification that takes up to 24 hours. Starting it first means you are not blocked later.

1.1 — Create the AWS free tier account

  1. Open a browser and go to aws.amazon.com.
  2. Click the orange "Create an AWS Account" button in the top right.

📋 What you will see: A page asking for an email address, a password, and an account name. The account name is a display label — it does not need to be public or permanent. Use something like your-name-cca-f-learning.

  1. Enter your email address, choose a strong password (minimum 8 characters, mix of types), and enter an account name. Click Continue.
  2. On the next page, select Personal as the account type. Fill in your name and address. Click Continue.
  3. Enter a credit or debit card. AWS requires this for identity verification even for free tier usage. You will not be charged for the exercises in this curriculum, which stay within the free tier limits. Click Verify and Continue.

📋 What you will see: AWS may show a small temporary authorisation hold (typically $1 USD). This is reversed within a few days — it is not a purchase.

  1. Complete the identity verification step. AWS will call or text the phone number you provide with a PIN. Enter the PIN on screen. Click Continue.
  2. Select the Basic Support — Free plan. Click Complete sign up.
  3. Wait for the activation email before proceeding to 1.2. If activation takes more than 24 hours, check your spam folder and the AWS support page.

⚠️ Use a personal email address. Create your AWS account using a personal email, not your corporate one. Your AWS account is for learning and portfolio work — it should not be tied to your employer's email domain.

1.2 — Secure the root account with MFA

This step is non-negotiable. An AWS root account without MFA is a serious security risk. The exercises in Weeks P3–P5 create cloud resources that could incur unexpected costs if the account were compromised.

What you need before starting: A phone with an authenticator app installed. Recommended options:

  • Google Authenticator (iOS / Android) — free, simple
  • Authy (iOS / Android / desktop) — free, supports encrypted backups (recommended — easiest to recover if you lose your phone)
  • Microsoft Authenticator (iOS / Android) — free

Install one of these on your phone before continuing.

  1. Sign in to the AWS Management Console at console.aws.amazon.com.
  2. In the top right corner, click on your account name.
  3. From the dropdown menu, click "Security credentials".
  4. Scroll down to the "Multi-factor authentication (MFA)" section. Click "Assign MFA device".
  5. Enter a device name (e.g., my-phone), select "Authenticator app", click Next.

📋 What you will see: A QR code, plus two fields labelled "MFA code 1" and "MFA code 2".

  1. Open your authenticator app on your phone and add a new account by scanning the QR code. The app begins showing 6-digit codes that change every 30 seconds.
  2. Enter the first 6-digit code into "MFA code 1". Wait for the code to change (~30 seconds). Enter the new code into "MFA code 2". Click Add MFA.
  3. Test MFA immediately. Sign out, sign back in, and confirm AWS asks for your MFA code.

⚠️ Save your backup codes now. If you use Authy, enable encrypted backups in the app settings. For Google Authenticator, take a screenshot of the QR code before closing it and store it securely. Losing access to your authenticator app with no backup means a lengthy AWS account recovery process. Do not skip this.

1.3 — Create an IAM user for CLI access

The root account you just created is for console access and emergency recovery only. The AWS CLI (used in Week P5) must run as an IAM user with limited permissions — never as root. Create that IAM user now while the console is open.

  1. In the AWS console, search for IAM in the top search bar and open the IAM service.

  2. In the left sidebar, click Users → Create user.

  3. Enter a username: cca-f-cli-user. Click Next.

  4. On the permissions screen, select "Attach policies directly". Search for and attach these two managed policies:

    • AWSLambdaFullAccess
    • SecretsManagerReadWrite

    Then also add:

    • AmazonECS_FullAccess
    • AmazonEC2ContainerRegistryFullAccess
    • CloudWatchFullAccess
    • IAMFullAccess (needed in Module 3 to create Lambda/Fargate execution roles)

📋 Why these permissions — and an honest caveat. Week P5 creates a Lambda function and a Secrets Manager secret; Module 3 deploys to Fargate and pushes images to ECR. The broad *FullAccess managed policies above are used here to keep this a single, low-friction setup step so you can focus on the AI architecture rather than IAM tuning. Be clear-eyed about the trade-off, though: these are broad permissions, and IAMFullAccess attached to a long-lived access key is exactly the kind of over-permissioning you will learn to design against in Module 7 (Week 36, least privilege and zero-trust). This is acceptable for a personal, throwaway learning account; it is not a pattern to copy into any shared, client, or production environment. If you want to practise the production-correct approach now, scope a custom policy to just the actions these exercises use, or delete this user and its access key once you finish Module 3. Treat this as a deliberate learning-environment shortcut, not a recommended default.

  1. Click Next → Create user.
  2. Click on the newly created user → Security credentials tab → Create access key.
  3. Select "Command Line Interface (CLI)" as the use case. Acknowledge the recommendation. Click Next → Create access key.
  4. Copy both the Access Key ID and the Secret Access Key now — the secret key is only shown once. Paste them into a temporary document. You will use them in Section 6 (AWS CLI setup).

⚠️ Treat these like a password. The access key gives programmatic access to your AWS account. Never commit it to Git, paste it into chat, or include it in code. You will store it in the AWS CLI credentials file on your local machine, which is not version-controlled.

1.4 — Note your AWS Account ID

You will need your 12-digit AWS Account ID when running CDK deployments and creating IAM role ARNs in Modules 0 and 3.

  1. In the AWS console top-right, click your account name. Your Account ID is displayed in the dropdown (format: 123456789012).
  2. Copy it and save it somewhere accessible — a text note, your journal, or a password manager entry.

Section 2 — Python 3.14+

Python 3.14 is the version the curriculum standardises on throughout — it appears in Dockerfiles, Lambda runtimes, and all code examples. Install 3.14 specifically, not just any 3.x version.

2.1 — Check if Python 3.14 is already installed

Open a terminal:

  • Windows: Press Win + R, type cmd, press Enter.
  • macOS: Press Cmd + Space, type Terminal, press Enter.
  • Linux: Press Ctrl + Alt + T.
python --version

If you see Python 3.14.x, Python is already installed at the right version. Skip to 2.3.

On macOS and Linux, also try:

python3 --version

If this returns Python 3.14.x, skip to 2.3 — and note that on these platforms, python3 is the native command. Section 2.2 shows how to align this.

2.2 — Install Python 3.14

Windows

  1. Go to python.org/downloads in your browser.
  2. Click the "Download Python 3.14.x" button. (If the page auto-suggests a different version, scroll down to "Looking for a specific release?" and select Python 3.14.x from the list.)

📋 Download the 3.14.x release specifically. The curriculum Dockerfiles and Lambda runtime both use python3.14. Using a different minor version creates a version mismatch that surfaces during container exercises in Week P4.

  1. Run the downloaded installer. Before clicking Install Now:

⚠️ Critical: At the bottom of the first installer screen, check the box labelled "Add python.exe to PATH". This box is unchecked by default. If you skip it, Python will install but will not be runnable from the terminal.

  1. Click "Install Now".
  2. Close your terminal and open a new one. Verify:
python --version

Expected: Python 3.14.x.

macOS

  1. Go to python.org/downloads. Scroll to "Looking for a specific release?" and download Python 3.14.x for macOS.
  2. Open the downloaded .pkg file and follow the standard macOS installation steps.
  3. Open a new Terminal and verify:
python3 --version

Expected: Python 3.14.x.

Align the python command on macOS:

echo 'alias python=python3' >> ~/.zshrc && source ~/.zshrc

Verify: python --version should now return Python 3.14.x.

📋 Apple Silicon (M1/M2/M3) users: The python.org 3.14 installer provides a universal binary that runs natively on Apple Silicon. No Rosetta needed.

Linux (Ubuntu / Debian)

sudo apt update
sudo apt install python3.14 python3.14-venv python3-pip -y
sudo update-alternatives --install /usr/local/bin/python python /usr/bin/python3.14 1
python --version

Expected: Python 3.14.x.

2.3 — Verify pip

pip is the Python package manager. Verify it is present and tied to Python 3.14:

pip --version

Expected output includes (python 3.14) at the end.

On macOS/Linux, if pip is not found but pip3 is:

echo 'alias pip=pip3' >> ~/.zshrc && source ~/.zshrc

2.4 — Troubleshooting Python

"Python is not recognised" after installation (Windows) Close the terminal and open a new one. Windows terminals do not pick up PATH changes in an open session. If still not found: search "Edit the system environment variables" → Environment Variables → System variables → Path → verify Python 3.14 entries are present.

Two Python versions coexisting The alias approach in Section 2.2 is the correct fix. Do not uninstall Python 2 on macOS — the system uses it internally on older versions.

"Permission denied" when running pip (Linux) Use pip install --user package-name or activate a virtual environment first (covered in Week P1).

Section 3 — Visual Studio Code

VS Code is used throughout the curriculum for writing Python, reading JSON, editing YAML, and working with Markdown documentation.

3.1 — Install VS Code

  1. Go to code.visualstudio.com.
  2. Click the large download button. The site detects your OS automatically.

Windows: Run the .exe installer. On the "Select Additional Tasks" screen, check "Add to PATH (requires shell restart)".

macOS: Open the downloaded .zip. Drag Visual Studio Code.app into your Applications folder. Launch from Applications, not Downloads.

Linux (Ubuntu/Debian):

sudo dpkg -i ~/Downloads/code_*.deb
sudo apt install -f

3.2 — Install the Python extension

  1. In VS Code, click the Extensions icon in the left sidebar (four squares icon).
  2. Search for Python. Install "Python" by Microsoft.
  3. When prompted to select a Python interpreter, choose the Python 3.14 version you installed.

3.3 — Install two additional extensions

GitLens (by GitKraken) — adds inline Git history and makes repository navigation much easier.

Prettier - Code formatter (by Prettier) — auto-formats JSON and Markdown files on save, keeping your work consistent.

Search for each in the Extensions panel and install.

3.4 — Verify VS Code is working

  1. Press Ctrl+N (Windows/Linux) or Cmd+N (macOS) to open a new file.
  2. Type: print("VS Code and Python are working")
  3. Save as test.py (Ctrl+S / Cmd+S).
  4. Run: Ctrl+F5 (Windows/Linux) or right-click → "Run Python File in Terminal".

Expected terminal output: VS Code and Python are working

Delete the test file after verification.

3.5 — Troubleshooting VS Code

"No Python interpreter selected" Click the Python version indicator in the VS Code bottom-left status bar. Select Python 3.14 from the dropdown. If no options appear, restart VS Code after confirming Python is installed.

Extension installation fails (corporate network) Some corporate networks block marketplace.visualstudio.com. Try a personal network, or ask IT to whitelist it.

Section 4 — Git

Git tracks changes to your files and synchronises your work with GitHub.

4.1 — Check if Git is already installed

git --version

If you see git version 2.x.x, skip to 4.3.

4.2 — Install Git

Windows

  1. Go to git-scm.com/download/win. The download starts automatically.
  2. Run the installer. Important settings on specific screens:
    • Default editor: change from Vim to Visual Studio Code
    • Initial branch name: select "Override" and type main
    • PATH environment: keep "Git from the command line and also from 3rd-party software"
    • All other screens: accept defaults.
  3. Open a new terminal and verify: git --version

macOS

git --version

If Git is not installed, macOS prompts: "The 'git' command requires the command line developer tools. Would you like to install the tools now?" Click Install (~1 GB download). After installation, verify: git --version

Linux (Ubuntu / Debian)

sudo apt update && sudo apt install git -y
git --version

4.3 — Configure Git with your identity

Run both commands, substituting your own details. Use the same email you will use for GitHub.

git config --global user.name "Your Name"
git config --global user.email "your@email.com"
git config --global core.editor "code --wait"
git config --global init.defaultBranch main

Verify:

git config --global --list

Expected: user.name, user.email, core.editor, and init.defaultBranch all listed with your values.

Section 5 — GitHub Account

GitHub is where your portfolio repositories live. Prospective employers and consulting clients will visit your GitHub profile to evaluate your work.

5.1 — Create a GitHub account

  1. Go to github.com → "Sign up".
  2. Use the same email you configured with Git in Section 4.3.
  3. Choose a username. Use something professional — firstname-lastname or firstnamelastname work well. This appears in every repository URL and on your CV.
  4. Complete verification and confirm your email.

5.2 — Set up your GitHub profile

  1. Click your avatar (top right) → "Your profile" → "Edit profile".
  2. Fill in your real name, a one-sentence bio (e.g., "Enterprise IT architect | AI architecture | CCA-F candidate"), and your location.
  3. Click Save.

5.3 — Enable two-factor authentication on GitHub

  1. Click your avatar → Settings → "Password and authentication" → "Enable two-factor authentication".
  2. Choose "Authenticator app" (you already have one from Section 1.2).
  3. Scan the QR code, enter the confirmation code.
  4. Download and store the recovery codes — these are your way back in if you lose your phone. Store them in a password manager or print them.

5.4 — Connect Git to GitHub with SSH

This lets your terminal push code to GitHub without typing a password every time.

Step 1 — Generate an SSH key pair

ssh-keygen -t ed25519 -C "your@email.com"

Press Enter to accept the default file location. You can set a passphrase or leave it blank.

Step 2 — Copy the public key

cat ~/.ssh/id_ed25519.pub

Windows alternative: type %USERPROFILE%\.ssh\id_ed25519.pub

Copy the entire output line (starts with ssh-ed25519, ends with your email).

Step 3 — Add to GitHub

  1. GitHub → avatar → Settings → SSH and GPG keys → New SSH key.
  2. Give it a title (e.g., My laptop), paste the public key, click Add SSH key.

Step 4 — Test the connection

ssh -T git@github.com

Type yes when asked about authenticity. Expected: "Hi your-username! You've successfully authenticated..."

5.5 — Create a GitHub Personal Access Token for container registry access

Week P4 pushes Docker images to the GitHub Container Registry (GHCR). This requires a Personal Access Token (PAT) with write:packages permission. Create it now while GitHub is open.

  1. GitHub → avatar → Settings → Developer settings (bottom of left sidebar) → Personal access tokens → Tokens (classic) → Generate new token (classic).
  2. Give it a descriptive name: cca-f-ghcr-access.
  3. Set an expiration — 90 days is a reasonable default for a learning project.
  4. Under Select scopes, check:
    • write:packages
    • read:packages
    • delete:packages (useful for cleaning up test images)
  5. Click Generate token. Copy the token now — it is only shown once.
  6. Store it securely (password manager or a local .env-style file that is not committed to Git). You will use it in Week P4 when running docker login ghcr.io.

5.6 — Verify the full Git + GitHub connection

  1. On GitHub, click "+" → "New repository" → name it cca-f-setup-test → set to Private → check "Add a README" → Create repository.
  2. Click the green Code button → SSH tab → copy the URL.
  3. In your terminal:
cd ~/Desktop
git clone git@github.com:your-username/cca-f-setup-test.git
cd cca-f-setup-test
echo "Setup test" >> README.md
git add README.md
git commit -m "test: verify git push works"
git push
  1. Refresh the repository on GitHub — the README should show "Setup test" added.
  2. Delete the test repository: GitHub → repository Settings → scroll to bottom → Delete this repository.

Section 6 — Anthropic API Key

The Anthropic API key is required from Week P3 onwards, when you build the ClaudeClient that makes direct API calls. Without it, the exercises from Week P3 through the end of the curriculum cannot be completed.

6.1 — Create a free Anthropic account and API key

  1. Go to console.anthropic.com in your browser.
  2. Click "Sign up" and create an account using your personal email address.
  3. Complete email verification.
  4. Once in the console, navigate to Settings (left sidebar or top right) → API Keys.
  5. Click "Create Key". Name it cca-f-curriculum. Click Create.
  6. Copy the key immediately — it begins with sk-ant- and is only shown in full at creation. Store it in a secure location (password manager entry).

⚠️ This is a billing credential. The key gives access to paid Claude API calls. Never commit it to Git, paste it into chat, email it, or include it in screenshots. The curriculum's Module 1 Week 5 covers API key security in depth — the short version is: it goes in a .env file that is in .gitignore.

6.2 — Understand free tier and costs

New accounts receive a free credit allocation for API usage. The exercises in this curriculum use claude-haiku-4-5-20251001 by default — the cheapest and fastest model in the Claude family. Typical exercise runs cost fractions of a cent. The full curriculum (Modules 0–6) with typical exercise usage runs to approximately $5–15 in API costs depending on how much you experiment. Monitor your usage in the console under Usage.

Section 7 — Docker Desktop

Docker is required from Week P4 onwards, when you containerise your Claude service. It is also required throughout Module 3 (containerisation, cloud deployment) and Module 8 (data pipeline implementation).

7.1 — Install Docker Desktop

  1. Go to docker.com/products/docker-desktop.
  2. Download Docker Desktop for your operating system.

Windows:

  • Run the installer. When asked about WSL 2, accept — Docker Desktop uses WSL 2 as its backend on Windows and this produces better performance.
  • After installation, restart your computer.
  • Docker Desktop starts automatically on login. A small whale icon appears in the system tray when it is running.

macOS:

  • Open the downloaded .dmg file. Drag Docker.app to Applications.
  • Launch Docker from Applications. Accept the service agreement.
  • Docker Desktop starts running — the whale icon appears in the menu bar.
  • Apple Silicon (M1/M2/M3) note: Download the Apple Silicon version, not Intel. The download page detects this automatically if you are on a recent macOS version.

Linux (Ubuntu / Debian): Follow the official installation guide at docs.docker.com/engine/install/ubuntu/. The recommended method uses Docker's apt repository for automatic updates.

📋 Note: Docker Desktop is free for personal use and for organisations under certain size thresholds. Check docker.com/pricing if you are installing on a corporate device — enterprise licences may apply.

7.2 — Verify Docker is running

After installation, open a terminal and run:

docker --version
docker compose version

Expected output: version numbers for both. If Docker is not running, open Docker Desktop from your Applications folder and wait for the whale icon to show "Docker Desktop is running" (green dot).

Run a quick test:

docker run hello-world

Expected: a message beginning with "Hello from Docker! This message shows that your installation appears to be working correctly."

Section 8 — AWS CLI

The AWS CLI (command-line interface) lets you create Lambda functions, manage Secrets Manager, push to ECR, and configure Fargate deployments from your terminal. It is required from Module 0 Week P5 onwards.

8.1 — Install the AWS CLI

The AWS CLI v2 is the current version. Install it using the official installer rather than pip for the most reliable result.

Windows: Download and run the MSI installer from aws.amazon.com/cli/ → download for Windows.

macOS:

curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
sudo installer -pkg AWSCLIV2.pkg -target /
rm AWSCLIV2.pkg

Linux (Ubuntu / Debian):

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
rm -rf awscliv2.zip aws/

Verify the installation:

aws --version

Expected: aws-cli/2.x.x Python/3.x.x ...

📋 awscli vs boto3. The AWS CLI you're installing in this section (aws command) and boto3 (the Python SDK, import boto3, used starting Week P5's Secrets Manager code) are two separate installs. Run pip install boto3 before Week P5 — the CLI does not provide the Python import.

8.2 — Configure the AWS CLI with your IAM user credentials

Use the IAM user access key you created in Section 1.3.

aws configure

You will be prompted for four values:

  • AWS Access Key ID: the access key ID from Section 1.3
  • AWS Secret Access Key: the secret key from Section 1.3
  • Default region name: us-east-1 (the region used throughout the curriculum)
  • Default output format: json

Verify the configuration works:

aws sts get-caller-identity

Expected: a JSON response showing your Account ID, User ID, and ARN for cca-f-cli-user. If you see an error about credentials, re-run aws configure and check the keys are entered correctly (no leading/trailing spaces).

⚠️ Never run aws configure with your root account access keys. The IAM user you created in Section 1.3 is the correct identity for CLI work. Using root credentials in the CLI is an AWS security anti-pattern and can cause accidental account-wide changes.

Section 9 — Postman

Postman is used in Module 2 Week 9 to explore the Claude API at the raw HTTP level — inspecting request and response structure, testing parameters, and verifying API behaviour before wrapping it in Python code. The CCA-F exam tests API knowledge that Postman exercises reinforce. Install it before Module 2.

9.1 — Install Postman

  1. Go to postman.com/downloads.
  2. Download Postman for your operating system and run the installer.
  3. Create a free Postman account when prompted (required to save collections and environments).

9.2 — Verify Postman is working

  1. Open Postman.
  2. Click "New" → "HTTP Request".
  3. Set the method to GET, enter the URL https://httpbin.org/get, and click Send.

Expected: a JSON response body with your request headers echoed back. This confirms Postman can make HTTP requests from your machine.

You do not need to configure the Claude API connection now — that is covered step-by-step in Module 2 Week 9.

Section 10 — Node.js and Claude Desktop (install before Module 4)

Node.js and Claude Desktop are not needed until Module 4 Week 17. However, if you are on a corporate device, request IT approval well in advance — install times can be unpredictable in enterprise environments.

10.1 — Install Node.js (LTS version)

Node.js is required to run MCP servers (which are Node.js applications) and to install Claude Code via npm. Install the LTS (Long Term Support) version, not the current version.

  1. Go to nodejs.org.
  2. Click the "LTS" download button (left button — do not click "Current").

Windows/macOS: Run the downloaded installer. Accept defaults throughout.

Linux (Ubuntu / Debian):

curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs

Verify:

node --version
npx --version
npm --version

Expected: version numbers for all three. node should show v20.x or v22.x (LTS versions current at time of writing).

📋 A note on AWS CDK. npm install -g aws-cdk (see Section 13's Quick Reference) installs the CDK CLI (used to run cdk deploy etc.), which is Node.js tooling regardless of which language your stack code is written in. Module 3's stack code is written in Python CDK, a separate library installed via pip install aws-cdk-lib constructs. Install both the CLI (this section) and the Python library (via pip, before Module 3 Week 14) since they serve different purposes and neither substitutes for the other.

10.2 — Install Claude Desktop

Claude Desktop is the desktop application where you configure and test MCP servers in Week 17.

  1. Go to claude.ai/download.
  2. Download and install Claude Desktop for your operating system.
  3. Sign in with your Anthropic account (the same one you used to create your API key in Section 6).
  4. Verify Claude Desktop opens and you can send a basic chat message.

📋 Note on Claude Desktop version. Claude Desktop is updated frequently. Always use the latest version — older versions may not support the MCP configuration format used in Module 4. Check for updates in the Claude Desktop menu if you installed it well before starting Module 4.

Section 11 — Module 8 Dependencies (install before Week 41 only)

Module 8 introduces data pipeline implementation tools not needed in Modules 0–7. Install these only when you are ready to start Week 41 — not at initial setup.

11.1 — Install Module 8 Python packages

📋 Versions pinned deliberately — Module 8's code targets these specific API surfaces; newer major versions of both libraries have breaking changes.

pip install --break-system-packages \
    sentence-transformers pgvector psycopg2-binary \
    ragas datasets rank-bm25 prefect==2.19.0 great-expectations==0.18.19 \
    pydantic boto3 langchain-core

📋 Note on --break-system-packages: This flag is required on some platforms to install into the system Python rather than a virtual environment. If you are using a virtual environment (recommended), omit this flag and run the pip install command without it.

Verify the key packages imported correctly:

python -c "import sentence_transformers; print('sentence-transformers OK')"
python -c "import prefect; print('prefect OK')"
python -c "import great_expectations; print('great-expectations OK')"

11.2 — Download the embedding model

The first time you use SentenceTransformer it downloads an ~80MB model. Download it now so the first pipeline run is not delayed:

python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2'); print('Model downloaded OK')"

⚠️ Ensure you are on an unrestricted network before running this. The model downloads from Hugging Face. If your corporate network blocks Hugging Face, use a personal device or hotspot for this step.

11.3 — Confirm Docker is still running

Module 8 Week 41 starts a pgvector PostgreSQL container. Verify Docker Desktop is still installed and running:

docker --version
docker run hello-world

If Docker Desktop is not running, open it from your Applications folder and wait for the green status indicator before proceeding.

Section 12 — Final Verification Checklist

Open a terminal and run each command. Every command should produce output — no errors.

python --version

Expected: Python 3.14.x

pip --version

Expected: pip 2x.x from ... (python 3.14)

git --version

Expected: git version 2.x.x

git config --global user.name

Expected: Your name

git config --global user.email

Expected: Your email address

ssh -T git@github.com

Expected: Hi your-username! You've successfully authenticated...

docker --version
docker compose version

Expected: version numbers for both

aws --version

Expected: aws-cli/2.x.x

aws sts get-caller-identity

Expected: JSON showing your Account ID and cca-f-cli-user ARN

node --version
npm --version

Expected: LTS version numbers (install these before Module 4 — listed here for completeness)

Checklist — confirm each item before starting Week P1:

  • Python 3.14.x installed — python --version returns 3.14.x
  • pip works and is tied to Python 3.14
  • VS Code installed, Python extension installed, test file runs successfully
  • Git installed and configured with name and email
  • GitHub account created, email verified
  • GitHub two-factor authentication enabled and recovery codes saved
  • SSH key added to GitHub — ssh -T git@github.com succeeds
  • GitHub Personal Access Token created with write:packages scope and stored securely
  • AWS account created, activation email received
  • AWS root account MFA enabled and tested (sign out and back in)
  • AWS IAM user cca-f-cli-user created with required policies
  • AWS access key ID and secret key copied and stored securely
  • Anthropic account created and API key (sk-ant-...) copied and stored securely
  • Docker Desktop installed — docker run hello-world succeeds

Before Module 2 (complete any time between now and Week 9):

  • Postman installed and can send a test request

Before Module 4 (complete any time between now and Week 17):

  • Node.js LTS installed — node --version and npx --version both return versions
  • Claude Desktop installed and signed in

Before Module 8 (complete any time before Week 41 — post-certification optional track):

  • Module 8 Python packages installed — sentence-transformers, prefect, great-expectations all import without error
  • Docker Desktop still installed and docker run hello-world succeeds
  • SentenceTransformer('all-MiniLM-L6-v2') model downloaded successfully (~80MB)

Section 13 — Quick Reference: Key Commands

Once setup is complete, these are the commands you will use most frequently.

Python

python --version                      # Check version
python script.py                      # Run a Python script
python -m venv venv                   # Create a virtual environment
source venv/bin/activate              # Activate venv (macOS/Linux)
venv\Scripts\activate                 # Activate venv (Windows)
pip install package-name              # Install a library
pip install -r requirements.txt       # Install all dependencies
pip freeze > requirements.txt         # Export current dependencies

Git

git init                              # Start tracking a folder as a Git repository
git status                            # See what has changed
git add .                             # Stage all changes for commit
git commit -m "message"               # Save a snapshot with a description
git push                              # Upload commits to GitHub
git pull                              # Download latest changes from GitHub
git checkout -b feature/branch-name  # Create and switch to a new branch
git log --oneline                     # View commit history

Docker

docker --version                      # Check version
docker build -t image-name:tag .      # Build an image from a Dockerfile
docker run -p 8000:8000 image-name    # Run a container with port mapping
docker run -e KEY=value image-name    # Run a container with env variable injected
docker compose up --build             # Start all services defined in docker-compose.yml
docker compose down                   # Stop all services
docker ps                             # List running containers
docker images                         # List built images
docker login ghcr.io -u USERNAME --password TOKEN  # Log in to GitHub Container Registry

AWS CLI

aws --version                         # Check version
aws configure                         # Set credentials and region
aws sts get-caller-identity           # Verify current identity
aws secretsmanager create-secret ...  # Create a secret
aws lambda create-function ...        # Create a Lambda function
aws lambda invoke ...                 # Invoke a Lambda function
aws ecr get-login-password ...        # Get ECR authentication token

Terminal navigation

pwd                                   # Print current directory (macOS/Linux)
cd folder-name                        # Navigate into a folder
cd ..                                 # Navigate up one level
ls                                    # List files (macOS/Linux)
dir                                   # List files (Windows)
mkdir folder-name                     # Create a new folder

Node.js / npm (used from Module 4 onwards)

node --version                        # Check Node.js version
npm install -g aws-cdk                # Install AWS CDK globally
npm install -g @anthropic-ai/claude-code  # Install Claude Code CLI
npx --version                         # Check npx version

Section 14 — Notes for Corporate / Managed Devices

If you are on a corporate-issued device, additional steps may be required. Request approvals early — enterprise IT processes typically take 1–2 weeks.

Python 3.14: May need to be requested through your internal software catalogue. Alternatively, complete setup on a personal device.

VS Code: Usually available through corporate software catalogues. Free and widely used — approval is generally straightforward.

Git for Windows: Requires no special privileges on most corporate Windows machines. If blocked, request it through IT or use the portable version from git-scm.com.

Docker Desktop: Requires either a paid Docker subscription for qualifying organisations, or IT approval to use the personal-use tier. Also requires WSL 2 on Windows (which may itself require IT approval). Allow extra time for this one.

GitHub access: Some organisations block github.com on corporate networks. You will need a personal network (mobile hotspot) for repository operations, or IT approval to whitelist GitHub.

Node.js: May require admin rights or a security review. Requested as: "Node.js LTS for running local MCP server processes during AI architecture training — no internet-facing service involved."

Module 8 Python packages (if completing the data pipeline track): sentence-transformers downloads an ~80MB embedding model on first use. If your corporate device restricts large downloads or model files, test this before starting Week 41: pip install sentence-transformers --break-system-packages && python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')". If it fails, run Module 8 on a personal device or cloud environment.

Claude Desktop: A desktop AI application — approval requirements vary widely by organisation. Frame it as: "Local AI development tool for connecting to Anthropic APIs, used in structured training exercises."

AWS CLI: Install is straightforward; the authentication uses IAM user credentials stored in ~/.aws/credentials (not version-controlled), which is the standard enterprise pattern for developer workstations.

AWS account on corporate email: Always use a personal email for your training AWS account. Do not use your corporate email — this creates entanglement with your employer's billing and identity management.

Setup complete. You are ready to begin Module 0 Week P1.

When you reach Module 8, return to Section 11 of this guide to install the additional data pipeline dependencies before starting Week 41.

Done here? Continue to Module 0 — Prerequisite Track.

Jump to top ↑