Software development syllabus
The required learning outcomes and practical work for all 24 phases. This is a one-year, full-time programme, taught online or onsite in Nyamarambe, Kisii.
Computing and product foundations
Weeks 1–2
The Story of Computing
- Explain how computing developed from counting tools to programmable machines, and the problems each advance solved.
- Demonstrate binary states and AND, OR and NOT; explain input, processing, storage and output.
- Explain vacuum tubes, transistors, integrated circuits and Moore’s Law as a historical observation; identify computing eras and careers.
- Use files, accounts, documents, spreadsheets and the learning platform safely.
Practical work
Build a computing map, trace a familiar task through a computer and demonstrate a logic operation. Complete practical setup checks.
Weeks 3–4
Computer systems and developer tools
- Explain the operating system, processor, memory, storage and running processes using a supplied program.
- Navigate files, run a project, inspect errors and use terminal commands safely.
- Track changes with Git, create a branch, submit a pull request and resolve a small merge conflict.
- Use documentation to investigate setup problems and write instructions others can follow.
Practical work
Repair a broken development setup and submit a reviewed documentation change. Demonstrate the repair, explain local and remote work, and recover a mistaken edit.
Weeks 5–6
Product planning and user research
- Distinguish users, customers, payers and stakeholders; research user behaviour and build a persona that separates evidence from assumptions.
- Map a user journey, test a prototype and define a minimum viable product (MVP), including what to leave out and how to check it works.
- Model build and running costs, pricing or funding, break-even and cash timing; explain the effects of scope and payment changes.
- Select key performance indicators (KPIs), calculate them from supplied data and plan how to collect accurate measurements.
Practical work
Submit a product brief linking research, persona, prototype, scope, costs and KPIs. Explain and revise a recommendation when the budget, user needs or measurement assumptions change.
Programming and problem-solving
Weeks 7–8
Programming fundamentals
- Trace values and control flow in JavaScript before running the program.
- Use variables, types, operators, conditions and loops to meet a requirement.
- Validate input and distinguish syntax, runtime and logic errors.
- Explain normal and boundary cases using examples, units and Boolean reasoning.
Practical work
Trace, modify and write short programs, then explain their behaviour with changed input. Use Git to record clear changes and recover an edit.
Weeks 9–10
Functions, collections and testing
- Divide a requirement into functions with clear inputs, outputs and responsibilities.
- Use arrays, objects, maps and sets to store, count, filter and transform data.
- Test ordinary, boundary and invalid inputs, and demonstrate a test catching a defect.
- Change another person’s program while preserving its required behaviour.
Practical work
Build a tested program and exchange it for a maintenance task. Submit code and run instructions, explain a design choice, repair a fault and respond to a changed requirement.
Weeks 11–12
Program design, types and files
- Organise modules and separate data, behaviour and input/output.
- Read, write and validate CSV or JSON; handle missing or malformed files without corrupting data.
- Use TypeScript types, interfaces and narrowing alongside runtime validation.
- Compare functions, composition and classes; use encapsulation and state deliberately.
Practical work
Add persistent data to your program, refactor it and compare two designs. Explain an object-oriented example, repair a data defect and show another person how to run the project.
Weeks 13–14
Algorithms, debugging and asynchronous work
- Choose collections and explain how time and memory use change as input grows.
- Implement and test a small algorithm, comparing it with a library alternative.
- Reproduce a defect, test a hypothesis, inspect execution and verify the repair with a regression test.
- Use promises to handle asynchronous success, failure and execution order.
Practical work
Investigate a slow or incorrect program and test a justified change on different inputs. Complete an asynchronous exercise and explain a new debugging task.
Weeks 15–16
Programming practice and review
- Correct gaps in programming, testing and tool use.
- Solve an unfamiliar problem with concepts already taught.
- Explain an earlier mistake, correct it and verify the result on new input.
- Identify the practice or help needed for database and web work.
Practical work
Use diagnostics and workshops to revise earlier work. Individually trace, write, test and repair a program, and demonstrate Git and setup skills.
Data, interfaces and full-stack development
Weeks 17–18
Databases and SQL
- Design related tables with suitable keys, types and constraints; explain normalisation.
- Answer questions with SQL filters, joins, grouping, aggregates and subqueries.
- Explain what each row represents and identify missing records, nulls and double counting.
- Use parameterised queries and a transaction; demonstrate a constraint preventing invalid data.
Practical work
Model a product domain, import data and submit a schema, setup scripts, data dictionary and queries. Correct an inaccurate query result and explain the error.
Weeks 19–20
Interaction design, HTML and CSS
- Turn a user journey into clear content, navigation and feedback.
- Use semantic HTML, forms and responsive CSS; explain the browser structure.
- Provide keyboard access, visible focus, labels, text alternatives and readable content.
- Observe a user attempting the task and make a justified usability improvement.
Practical work
Publish a static preview of your product’s main flow and test it on a small screen and with a keyboard. Revise it after a usability session, explain a design choice and repair an interaction barrier.
Weeks 21–22
Browser programming and the web
- Respond to browser events and update the document with clear application state.
- Trace a URL through DNS, a connection, HTTP, the server and browser response handling.
- Fetch data and handle loading, empty, success, validation and failure states.
- Use browser tools to distinguish interface, network and server errors.
Practical work
Connect your interface to a supplied API and investigate delays, failures and malformed responses. Trace a request, repair a fault and demonstrate useful user feedback.
Weeks 23–24
Backend development and APIs
- Build a TypeScript/Node.js API with request handling, validation and errors.
- Connect PostgreSQL with safe queries and controlled schema changes.
- Describe the API contract and test valid, invalid and missing-data cases.
- Connect a browser flow and deploy it to restricted staging through a repeatable process.
Practical work
Implement one flow across browser, API and database, review its contract and add integration tests to continuous integration. Implement or repair a route and explain its query.
Weeks 25–26
Identity, security and data correctness
- Distinguish authentication, authorisation and sessions using a maintained implementation.
- Enforce server permissions and test that users cannot access another user’s restricted records.
- Use constraints or transactions to preserve a business rule during concurrent requests.
- Validate a simulated callback, prevent duplicate processing and handle failure explicitly.
Practical work
Protect the service and investigate a double booking or repeated callback. Demonstrate a denied action, a concurrent-request test and the repair.
Weeks 27–28
React and full-stack development
- Build components with clear state ownership, forms and navigation.
- Connect the API while preserving accessibility, errors and permission-denied states.
- Write component tests and an end-to-end test for a meaningful user task.
- Trace an interaction to its stored result and justify new abstractions.
Practical work
Rebuild a familiar browser feature in React, compare the implementations and release it to staging. Change a requirement and verify the behaviour with tests.
Weeks 29–30
Full-stack practice and review
- Trace and troubleshoot a user flow across interface, API and database.
- Correct gaps in SQL, browser state, testing, accessibility and access control.
- Apply an earlier skill in a changed implementation.
- Explain the responsibilities you can take on in a supervised team.
Practical work
Complete and check the application’s core flow. In a different example, explain a query, make a full-stack change and verify a failure or permission case.
Delivery, analysis and improvement
Weeks 31–32
Residency I: contributing to an existing project
- Set up an unfamiliar codebase and trace one feature through it.
- Clarify a task, agree acceptance criteria and estimate the work with stated assumptions.
- Deliver a reviewed change with regression tests and respond to feedback.
- Communicate progress, blockers and a usable handover.
Practical work
Onboard, complete a small change and take it through review, testing and handover. Submit your contribution record and explain the changed code.
Weeks 33–34
Deployment, reliability and maintenance
- Build and deploy repeatedly with separate environments and controlled secrets.
- Recover from a failed change and restore a database backup in an isolated environment.
- Investigate performance or reliability with logs, measurements and a stated workload.
- Make a safe dependency change and explain costs, operational limits and support responsibilities.
Practical work
Deploy your application, exercise a failure and demonstrate recovery. Submit an operating guide, cost estimate and diagnostic report.
Weeks 35–36
Applied data analysis
- Define the decision, population and unit of analysis; inspect data sources and limitations.
- Clean and combine data with documented SQL or spreadsheet steps while preserving raw input.
- Investigate a question with suitable summaries, comparisons and charts.
- Explain findings, uncertainty and the actions the evidence supports.
Practical work
Submit a reproducible analysis with a question, data dictionary, calculations, chart and recommendation. Have a peer reproduce it, then diagnose an unfamiliar data error.
Weeks 37–38
Product analytics and experimentation
- Define KPIs and measures that flag problems elsewhere in the product, with eligible users, counting rules and observation windows.
- Test event triggers, identity, retries, exclusions and privacy settings.
- Build a funnel or cohort analysis and reconcile it with source records.
- Evaluate a change while distinguishing observations, statistical uncertainty and causal evidence.
Practical work
Submit metric definitions, an event contract, tracking tests, a reconciled report and a recommendation. Verify PostHog results with samples and SQL, and explain an inconsistent metric.
Weeks 39–40
Building and evaluating an AI feature
- Choose a low-risk AI task and compare it with a manual or rules-based alternative.
- Integrate a model service with controlled inputs, validated outputs and clear data boundaries.
- Evaluate normal, ambiguous and adversarial cases with stated criteria and test examples kept separate from development.
- Demonstrate cost and latency limits, failure handling, a fallback and human review.
Practical work
Build a small AI feature and record its prompts, configuration and evaluation results. Investigate errors, prompt injection, disclosure risks and service failure, then change a control and measure the effect.
Weeks 41–42
Residency II: maintenance and handover
- Investigate a new repository, framework or domain using documentation and reproducible experiments.
- Complete a maintenance, integration or measurement task with reviewed verification.
- Handle changed requirements and explain the effect on scope, cost or timing.
- Write a handover another person can act on without a live briefing.
Practical work
Submit and explain a reviewed contribution, decision record and handover from a second unfamiliar context. Use the work to refine your CV, portfolio case study and interview explanation.
The six-week final project
Weeks 43–44
Final project: discovery and first implementation
- Investigate a problem and separate user evidence from the team’s preferred solution.
- Agree release scope, acceptance criteria, risks and responsibilities.
- Produce a design, data model, cost estimate and measurement plan.
- Build an end-to-end flow and explain each member’s contribution.
Practical work
Submit a brief, prototype, design and working end-to-end flow. Explain your contribution and respond to a changed-condition question.
Weeks 45–46
Final project: verification and release
- Complete the core flow with correct data handling and useful failure behaviour.
- Demonstrate tests, access controls, accessibility and operational readiness.
- Validate measurement and release to an approved limited audience.
- Explain outstanding risks, scope changes and the recovery and support plan.
Practical work
Complete the release checks with an independent reviewer. Demonstrate your implementation and complete an individual change or investigation task.
Weeks 47–48
Final project: operation, improvement and handover
- Investigate feedback and service behaviour, checking data quality and limitations.
- Implement and verify a justified improvement or corrective change.
- Demonstrate maintenance or recovery and hand over operating instructions.
- Explain your contribution and decisions, and apply a key skill to a new task.
Practical work
Submit the project’s brief, reviewed code, tests, release, analysis, improvement and handover. Demonstrate your contribution, explain decisions and complete an unfamiliar task.
Assessment and graduation
Assessment runs throughout the year through projects, code reviews, demonstrations and individual practical tasks. Instructors review your progress and provide focused teaching where you need more practice.
To graduate, you must independently demonstrate all eight programme capabilities through your own work and individual practical tasks. The final assessment brings together your project, technical decisions, individual contribution and handover.