One product, six modules. Each of us builds one module and takes one shared job. We join the modules through reviewed pull requests, run the product on Azure and demo it live.
Shared jobs, one each: CI, Docker Compose, Azure deployment, frontend, database, code review, documentation. That is seven jobs for six people, so one stays open or is shared. We decide it in step 5.
Each milestone is a Blackboard assignment. Paste the links below in the Steps tab so the whole team sees them before someone submits. Both milestone pages on Blackboard still say "Placeholder", so the details can change.
main goes through a reviewed pull request, merged with a merge commit..env files. A secret that was committed must be revoked.git push --force on a branch other people use.Start with stage 0: put in who has which module and shared job, then pick a name on each One person step. Every step then shows who does it. One person steps are done once for the team. Each member means all six do it for themselves. Job owner is whoever took that shared job.
Tick a step when it is done; the whole team sees the same ticks within a few seconds. Paste links in the amber boxes. Anyone with this link can tick and add links, so keep the link inside the team.
Do the stages in order. Laptop your terminal GitHub github.com Blackboard blackboard.ie.edu Azure portal.azure.com link to share
Fill this in together at the first meeting. It saves for the whole team, and every step below shows the name.
| Member | Module (from the theme) | Shared job |
|---|
Blackboard > Software Management & Development > Groups > Team 6. Then read the announcement "Course update: evaluation, use of AI and group project" and the Assignment tab here.
gh auth statusIf it says you are not logged in, run gh auth login and choose GitHub.com, HTTPS, Yes, Login with a web browser. Send your GitHub username to the team.
Milestones 1 and 2 are both due Mon 23 Nov. Meet over the weekend or Monday morning: 45 minutes covers steps 4 to 6. Your own Checkpoint 2 (structure and data) is also due Mon 23 Nov, 12:00.
Three options, each already split into six modules. Every module has its own entity and a result to calculate, and links to the others with a foreign key. Our proposals, not course material; any theme works if it splits into six modules.
| Shared job | What you own | Taught in |
|---|---|---|
| Code review | Every pull request gets a review; reviews are fair and on time | Session 5 |
| Documentation | Team README: setup, conventions, module list, how to run | Sessions 5-6 |
| Database | Shared tables, naming, foreign keys between modules | Session 7 |
| Frontend | One site and navigation that holds every module's page | Session 10 |
| Docker Compose | The whole product runs with one command | Session 11 |
| CI | GitHub Actions run Ruff and tests on every pull request | Not yet in the course notes |
| Azure deployment | The product runs on Azure for the demo | Sessions 12-13 |
Fill in the table in stage 0 at the top, then copy it into the team README (stage 3).
Use the theme in the name. Make it public, or private with the professor added: ask if unsure.
cd ~/smd
gh repo create team6-THEME --public --add-readme --gitignore Python --clone
cd team6-THEMERun once per teammate, with their GitHub username. They get an email invite and must accept it.
gh api -X PUT repos/OWNER/team6-THEME/collaborators/USERNAME -f permission=pushOr on GitHub: the repo > Settings > Collaborators > Add people.
Accept the GitHub email invite first. The person who created the repo already has it.
cd ~/smd
gh repo clone OWNER/team6-THEMESame setup as your own repo (Lab 3), so Ruff and tests run in the team repo too. Merge it through a pull request.
cd ~/smd/team6-THEME
git switch -c chore/project-setup
uv init --package --name PACKAGE
uv add --dev ruff pytest
git add .
git commit -m "Set up the uv project with Ruff and pytest"
git push -u origin chore/project-setupRepo > Projects > Link a project > New project > Board. Name it "Team 6". Keep the columns Todo, In progress, Done.
Repo > Issues > New issue. Title "Module: NAME". In the body: the entity, its fields, the calculated result, the endpoints and the page (copy your row from the theme table). Assign yourself and add it to the board.
gh issue create -R OWNER/team6-THEME --title "Module: NAME" --assignee @me --body "Entity: ... Result: ... Endpoints: ... Page: ..."Blackboard > Group project · Milestone 1: Team and theme. Hand in what the assignment asks once its text is final (it still says "Placeholder"). Our best guess: the team repo link, the theme, the board link and the member / module / job table. Agree who submits first.
Read this draft together, change what the team wants, then it goes in the team README. It follows the course notes; the API and tests parts are previews until sessions 8 and 9 are published.
The first pull request of the team, done the course way.
git switch main
git pull
git switch -c docs/conventions
nano README.md
git add README.md
git commit -m "Add team conventions and member table"
git push -u origin docs/conventionsOn GitHub: Pull requests > New pull request, base main, compare docs/conventions. A teammate reviews it, then merge with Create a merge commit.
One GET that returns your entity as JSON is a good start; what counts as "first endpoint" is still open. FastAPI is taught in session 8, so check the course notes when they come out.
cd ~/smd/smd-app
git switch -c feature/first-endpoint
uv add "fastapi[standard]"# src/ledger/api.py (use your own package and entity)
from fastapi import FastAPI
app = FastAPI()
@app.get("/invoices")
def list_invoices():
return [{"id": 1, "number": "2026-001", "subtotal_cents": 12000}]uv run fastapi dev src/ledger/api.pyThen open http://127.0.0.1:8000/invoices and http://127.0.0.1:8000/docs.
Commit, push and merge it through a pull request in your repo, like Lab 5. Then paste the link to the file or the pull request.
Blackboard > Group project · Milestone 2: Conventions. Hand in what the assignment asks once its text is final. Our best guess: the README link and the six endpoint links from above.
Details follow the course: APIs (session 8), tests (9), frontend (10), Docker (11). Update these steps as each session is published.
How your own repo becomes part of the team repo is the first question for Alberto. Until he answers, this is our plan.
cd ~/smd/team6-THEME
git switch main
git pull
git switch -c feature/MODULECopy your module in following the agreed layout, run uv run ruff check and uv run pytest, commit, then git push -u origin feature/MODULE.
Title and two or three sentences: what it adds and how you checked it. One teammate reviews. Merge with Create a merge commit; never merge your own unreviewed work.
git switch feature/THEIRS, uv run pytest.Reviews count for your grade, so do real ones.
git pull --no-rebase origin mainNo conflict? Just git push and stop here. If Git reports a conflict, open each file it names, keep the right lines and delete every <<<<<<<, ======= and >>>>>>> marker. Then check none are left and finish the merge:
grep -rn "<<<<<<<" --exclude-dir=.venv --exclude-dir=.git .
git add FILES
git commit --no-edit
git pushDatabase, API and frontend start together and every module's page works. Docker Compose is taught in session 11.
docker compose up --buildAzure is taught in sessions 12 and 13. The course uses these services: Container Registry, Container Apps (API), Static Web Apps (frontend), Database for PostgreSQL, Container Apps secrets or Key Vault.
A workflow in .github/workflows/ that runs Ruff and pytest, then builds the images. Red means do not merge.
Screen recording of the product on Azure: every module's page, its calculated result, one request in the API docs. Only used if the live demo fails.
Whatever the Blackboard assignment asks once it is published: most likely the live URL, the Actions run and the video.
Short: the product, the six modules and how they link, the architecture on Azure, then the live demo. Every member shows their own module.
Check the live URL the morning of the demo. Have the backup video ready to play.
Draft answers. The first four follow the course notes; the tests and Azure answers are previews until sessions 9 to 13. Say them in your own words, about your own module.
Separation of concerns: each file has one reason to change. The model says what the thing is, storage or the database code says where it is kept, reports does the calculation, and the API or CLI talks to the outside. Dependencies point inwards, so the calculation never imports the API.
Through a foreign key: a column like client_id in my table that holds the primary key of a row in their table. It sits on the "many" side, and the database refuses an id that does not exist once foreign keys are on (PRAGMA foreign_keys = ON in SQLite; PostgreSQL always checks).
Floats cannot store most decimal amounts exactly, so sums drift by fractions of a cent. Integer cents in the database and Decimal in Python keep every amount exact.
On a feature branch, pushed to GitHub, as a pull request with a description. A teammate reviewed it, and it was merged with a merge commit, so the history shows exactly what happened.
It checks the calculated result on a normal case and an edge case against an answer worked out by hand. If it fails, GitHub Actions marks the pull request red and we do not merge it.
Not in the code or the repo. The database connection string is a secret in Container Apps (or Key Vault) and reaches the app as an environment variable.
Name the tool, what it was for and the prompts, as the course rule asks. Then explain the code it helped with line by line.