Nalla Labs Academy

Zero to Hero Software Engineering

A 26-week, dependency-ordered path that takes a complete beginner to a production-capable engineer. Fundamentals are locked down by the month-3 gate in week 13; the second half builds and operates real systems.

weeks
26
phases
11
projects
9
hours
~880

Stack: Go · HTML, CSS, plain JavaScript · Linux (Ubuntu LTS) · PostgreSQL · Docker · GitHub Actions · AWS Free Tier

Syllabus

Weeks 1–13 lock down the fundamentals. Weeks 14–26 build and operate real systems. Every phase ends in a deployed, defended project.

Phase 0

How computers work

The machine under the code

Ends with Shell scripting lab

Phase 1

Programming foundations (Go)

Thinking in programs

Ends with Projects 1 and 2

Phase 2

Data and persistence

Where data lives and stays correct

Ends with Project 3

Phase 3

Networks and the web

How bytes cross the world

Ends with HTTP server on raw TCP sockets

Phase 4

Backend engineering

Services other programs rely on

Ends with Project 4 live

Week 13 · Month-3 gate

A timed build-and-debug assessment and an oral request trace across Phases 0–4. Pass, or leave with a remediation plan. See the gate week

Phase 5

The browser and full stack

The user's side of the system

Ends with Project 5

Phase 6

Identity, security and hardening

Who can do what, safely

Ends with Project 6

Phase 7

Cloud, infrastructure and operations

Running software for real

Ends with Project 6 on AWS, operated

Phase 8

Architecture and distributed systems

Systems made of parts that fail

Ends with Project 7

Phase 9

AI-enabled engineering

Building with and on models

Ends with Project 8

Phase 10

Capstone and system design

Owning a system end to end

Ends with Capstone and defence

One product, eight projects

Every project evolves Chama Ledger, a tool for a savings group to record contributions, loans and payouts, from a command-line tool into an AI-enabled distributed system.

  1. Project 1 · Weeks 3

    Contribution calculator

    Command-line tool that takes members and amounts as arguments and prints balances and shares

    Scripted break: Floating-point money error (0.1 + 0.2); fix with integer cents

  2. Project 2 · Weeks 5

    Local ledger

    Stores members and transactions in JSON/CSV files; import, export, monthly report

    Scripted break: Half-written file after a crash corrupts the ledger; fix with atomic writes

  3. Project 3 · Weeks 6–7

    Database-backed ledger

    Same app on SQLite, then migrated to PostgreSQL with a proper schema and reports

    Scripted break: Two concurrent writes break the balance; fix with a transaction and constraints

  4. Project 4 · Weeks 10–12

    Chama REST API

    Go service exposing members, contributions and loans over HTTP with an OpenAPI spec

    Scripted break: Expired certificate and a slow query causing timeouts

  5. Project 5 · Weeks 14–15

    Full-stack web app

    Server-rendered web app for treasurers and members, built with Go templates and plain JavaScript

    Scripted break: CORS failure and a stored XSS through a member's name

  6. Project 6 · Weeks 16–19

    Authenticated production API

    Accounts, roles, audit log, rate limits and idempotency keys on payments; containerised, CI/CD, then rebuilt on AWS with OpenTofu and operated

    Scripted break: Broken access control (member reads another chama) and a failed deploy that must be rolled back

  7. Project 7 · Weeks 20–21

    Distributed ledger system

    Splits out a notification service and a payments service that ingests webhooks from a simulated mobile-money provider

    Scripted break: Duplicate webhook delivery double-credits a member; the consumer crashes mid-message

  8. Project 8 · Weeks 22–23

    AI-enabled chama assistant

    Members ask questions in plain language; the assistant answers from the ledger and the group's constitution and minutes; an MCP server exposes scoped tools

    Scripted break: A minutes document containing an injected instruction tries to trigger a payout tool

  9. Capstone · Weeks 24–26

    Learner-chosen system

    A new system built from a real stakeholder's requirements

    Scripted break: Instructor-run game day: an unannounced outage to diagnose

Each project is assessed on the same four artefacts: working deployed code; tests passing in ci; a short readme explaining decisions and trade-offs; a live walkthrough tracing one request through the whole system.

How a week runs

Monday class · 90 min · Instructor
Week context: why this week's topics exist, how they connect to last week, a live system trace.
Daily section · ~6 h, Mon–Fri · Learner, self-paced
About 1.5 h reading or video, 3.5 h hands-on lab, 30 min AI check, 30 min journal entry and a commit.
Wednesday class · 60 min · Instructor
Clinic: live debugging of learners' real errors, questions.
Friday class · 90 min · Instructor
The scripted break (the instructor injects a fault and learners debug it), then code review of the week's deliverable.
Automated checks · CI
Daily exercises are graded by GitHub Actions tests; learners see pass or fail within minutes.
Weekend · Learner
Optional catch-up only; no new material.

How every lesson works

  1. What problem does it solve, and what did people do before it existed?
  2. How does it work underneath, and what does it hide from the developer?
  3. When should it be used, when should it not, and what does it cost?
  4. Hands-on: build the smallest working thing, then break it on purpose and debug it.
  5. Security: what can go wrong, who could attack it, what could they reach, how would we detect, prevent and recover?
  6. AI check (from Phase 1): ask an assistant to explain or produce the same thing, then find what it got wrong.

The build loop

Learn→Build→Break→Debug→Test→Secure→Deploy→Improve