Understand computing and solve programming problems
Explain, write, trace, debug and test code; investigate problems with documentation and experiments.
Software development curriculum
We teach you to understand a user’s problem, decide what to build and work with a team to release a product to the market. You’ll learn the programming, design and data skills to run and improve it after launch.
Curriculum developed by Samuel Owino.
- Entry
- No coding experience required
- Duration
- One year, full-timeMonday–Friday, 8am–5pm
- Location
- Online or onsite in Nyamarambe, Kisii
What you’ll learn
Prepare for junior software-development work in a product team. Learn to take a task from brief to reviewed release, connecting technical decisions to user needs and costs.
Make informed product decisions
Research user needs, choose what belongs in the first release and work out the costs of building and running it.
Work correctly with data
Design relational databases, query and validate data, and keep records correct when requests fail or arrive at the same time.
Build usable web applications
Connect an accessible interface, server and database, and handle errors or interrupted tasks clearly.
Verify and protect the work
Write meaningful tests, enforce permissions, protect sensitive information and check AI-assisted work.
Release and maintain a product
Release a product, investigate failures, restore a backup and maintain its code.
Use data to evaluate a product
Check product measurements, produce analysis another person can reproduce and use the findings to decide what to improve.
Contribute dependably to a team
Clarify requirements, estimate work, explain your assumptions, raise risks early, respond to reviews and hand over work others can continue.
Projects
Take a product from research and a first prototype through development, launch and improvement. Each project gives you more responsibility for the technical work and the product decisions.
Programming project
Write a program, such as a booking tool, organise its code, add file storage and test its behaviour. Extend it as you learn new concepts.
Full-stack application
Turn a user need into a working application. Design the interface, build the API and database, and track how people use the product.
Two mentored project sprints
Spend two weeks on each contribution to an existing project, with a host team or in a teaching codebase. A mentor reviews your work from the first task through to handover.
Six-week final project
Work in a small team to build a product, complete a release review and launch to its first users. Use the final two weeks to act on feedback, improve the product and prepare its handover.
Course outline
24 two-week phases, from computing foundations to the final project.
Computing and product foundations
Weeks 1–6
Explore computing, use developer tools and turn user research into a product brief.
Weeks 1–2The Story of Computing
Explore computing history, binary logic and the digital tools used throughout the programme.
The Story of Computing
Explore computing history, binary logic and the digital tools used throughout the programme.- 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–4Computer systems and developer tools
Use the terminal and Git, understand computer systems and repair a development setup.
Computer systems and developer tools
Use the terminal and Git, understand computer systems and repair a development setup.- 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–6Product planning and user research
Research user needs, test a prototype, budget the first release and decide how to measure its results.
Product planning and user research
Research user needs, test a prototype, budget the first release and decide how to measure its results.- 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–16
Write, organise, test and debug JavaScript and TypeScript programs.
Weeks 7–8Programming fundamentals
Write JavaScript with variables, conditions and loops, and trace how a program runs.
Programming fundamentals
Write JavaScript with variables, conditions and loops, and trace how a program runs.- 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–10Functions, collections and testing
Organise code into functions, work with collections and write automated tests.
Functions, collections and testing
Organise code into functions, work with collections and write automated tests.- 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–12Program design, types and files
Use TypeScript, modules and validated CSV or JSON files to organise and extend a program.
Program design, types and files
Use TypeScript, modules and validated CSV or JSON files to organise and extend a program.- 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–14Algorithms, debugging and asynchronous work
Compare algorithms, investigate defects and use JavaScript promises for tasks that finish later.
Algorithms, debugging and asynchronous work
Compare algorithms, investigate defects and use JavaScript promises for tasks that finish later.- 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–16Programming practice and review
Practise programming, testing and Git through corrections and unfamiliar problems.
Programming practice and review
Practise programming, testing and Git through corrections and unfamiliar problems.- 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–30
Build a complete application with PostgreSQL, HTML, CSS, Node.js and React.
Weeks 17–18Databases and SQL
Design linked tables and use SQL to store, retrieve and check data.
Databases and SQL
Design linked tables and use SQL to store, retrieve and check data.- 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–20Interaction design, HTML and CSS
Build responsive, accessible interfaces with semantic HTML, CSS, Flexbox and Grid.
Interaction design, HTML and CSS
Build responsive, accessible interfaces with semantic HTML, CSS, Flexbox and Grid.- 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–22Browser programming and the web
Handle browser events, fetch API data and diagnose HTTP requests and interface failures.
Browser programming and the web
Handle browser events, fetch API data and diagnose HTTP requests and interface failures.- 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–24Backend development and APIs
Build an API with TypeScript and Node.js, connect PostgreSQL and put a working application online.
Backend development and APIs
Build an API with TypeScript and Node.js, connect PostgreSQL and put a working application online.- 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–26Identity, security and data correctness
Control access to data and prevent errors when requests arrive together or are repeated.
Identity, security and data correctness
Control access to data and prevent errors when requests arrive together or are repeated.- 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–28React and full-stack development
Build React components, manage state and connect a tested interface to your API.
React and full-stack development
Build React components, manage state and connect a tested interface to your API.- 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–30Full-stack practice and review
Trace and repair complete flows across React, the API and PostgreSQL.
Full-stack practice and review
Trace and repair complete flows across React, the API and PostgreSQL.- 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–42
Contribute to unfamiliar code, maintain software, analyse data and evaluate an AI feature.
Weeks 31–32Residency I: contributing to an existing project
Make a reviewed contribution with a host team or in a teaching codebase, with guidance from a mentor.
Residency I: contributing to an existing project
Make a reviewed contribution with a host team or in a teaching codebase, with guidance from a mentor.- 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–34Deployment, reliability and maintenance
Deploy software, restore backups and investigate reliability, performance and operating costs.
Deployment, reliability and maintenance
Deploy software, restore backups and investigate reliability, performance and operating costs.- 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–36Applied data analysis
Clean, combine and analyse data with SQL and spreadsheets, then explain the findings.
Applied data analysis
Clean, combine and analyse data with SQL and spreadsheets, then explain the findings.- 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–38Product analytics and experimentation
Track how people use a product with PostHog, check the results with SQL and decide what to improve.
Product analytics and experimentation
Track how people use a product with PostHog, check the results with SQL and decide what to improve.- 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–40Building and evaluating an AI feature
Integrate an AI service and evaluate its accuracy, cost, latency and failure handling.
Building and evaluating an AI feature
Integrate an AI service and evaluate its accuracy, cost, latency and failure handling.- 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–42Residency II: maintenance and handover
Complete a maintenance or measurement task with a host team or in a teaching codebase, with guidance from a mentor.
Residency II: maintenance and handover
Complete a maintenance or measurement task with a host team or in a teaching codebase, with guidance from a mentor.- 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–48
Research a problem, build a product and launch it to its first users. Improve it using their feedback.
Weeks 43–44Final project: discovery and first implementation
Research a user need, define the first release and build the product’s core task across the interface, server and database.
Final project: discovery and first implementation
Research a user need, define the first release and build the product’s core task across the interface, server and database.- 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–46Final project: verification and release
Test the product, complete the release review and launch to its first users.
Final project: verification and release
Test the product, complete the release review and launch to its first users.- 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–48Final project: operation, improvement and handover
Study user feedback and product data, make an improvement and hand over the code and operating instructions.
Final project: operation, improvement and handover
Study user feedback and product data, make an improvement and hand over the code and operating instructions.- 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.
Languages and tools
Learn JavaScript, then TypeScript. Use Git, the terminal and automated tests throughout your development work.
Interfaces
HTML, CSS and React
Backend and databases
Node.js, Express and PostgreSQL
Data analysis
SQL, spreadsheets and PostHog
How you’ll learn at Reduzer
See how teaching, practice and feedback fit together. Online and onsite students follow the same curriculum and assessment standards.
The working day
A manageable idea, a chance to try it, then time to put it to work. Support is part of the day.
- Monday–Friday
- 08:00–17:00
- Scheduled learning
- 36 hours 15 minutes / week
Joining online?
Your day combines live interaction, independent work and small-group work. You won’t spend the whole day on video.
A typical learning day
Recall & warm up
Bring back earlier learning, attempt a focused challenge and compare approaches.
Break
Explore an idea
Interactive teaching and worked examples make the reasoning visible.
Break
Try it with guidance
Apply what you’ve learned, with checks for understanding along the way.
Lunch
Make progress on your project
Project work, practice and scheduled individual support.
Break
Build, investigate & improve
Develop your solution, review the work and make revisions.
Reflect & prepare
Get targeted help, document your work, review progress and prepare for the next learning day.
Required preparation fits within scheduled learning time; challenges are shared in advance where useful. During project-intensive phases, targeted teaching replaces whole-class sessions you no longer need.
From explanation to independent work
Your instructor introduces a manageable idea and demonstrates the reasoning. You explain, predict, investigate or modify an example before creating your own solution. Guidance reduces as your understanding grows.
In programming, that can look like this
- 01
Predict
Explain what you think the code will do.
- 02
Run
Try it and observe what actually happens.
- 03
Investigate
Work through the result and the reasoning.
- 04
Modify
Change the example and test your understanding.
- 05
Make
Create a solution of your own.
How this carries into product, data and independent learning
In product or data work, you might inspect a claim, identify its assumptions, reproduce a calculation and decide what additional evidence is needed.
Short activities bring back earlier learning. You plan an approach, compare the result with what you expected and identify your next learning need. Temporary support groups address particular gaps; students are not assigned fixed ability or personality labels.
This approach draws on research on active learning, worked examples and programming instruction.
The two-week rhythm
Each phase gives you space to explore the ideas, develop your work and act on feedback.
Week 01Days 1–5
Learn & practise
Explore the main ideas, complete small tasks, compare approaches and get early feedback.
90 minutes for communication. Use the phase’s actual work: explain a bug, interview a user, present a chart or write a delivery update.
Week 02Days 6–10
Build, demonstrate & revise
Day 8: review-ready work is due. The last two days are for demonstrations, individual questions, practical checks and revisions.
Every student explains their own work and receives separate feedback on subject understanding and communication. Smaller practice tasks don’t all need presentations.
Feedback you can act on
- The issue
- Why it matters
- Your next action
- How we check improvement
When revisions and understanding are checked
Routine corrections continue in the next phase’s opening practice block and are checked by its second teaching day. A prerequisite needed immediately is checked before the dependent task begins. The final phase reserves its own correction and reassessment time.
Weekly individual check-ins
A scheduled individual meeting with your instructor, alongside help during practical work.
Monthly guest engineer sessions
A guest session with a leading Kenyan engineer. Guest sessions and career workshops replace normal learning blocks, without compulsory evening work.
Using AI during learning
Learn what you can produce with assistance—and what you understand for yourself.
During practice and development
Use approved AI tools for explanation, exploration, feedback and development assistance. Check the output, protect confidential information and disclose assistance that materially shaped assessed work.
During individual understanding checks
Follow the stated conditions, including tasks without solution-generating AI or another person’s answers. Documentation and accessibility tools remain available when the assessment permits them.
Why we check both
The purpose is to establish what you understand alongside what you can produce with assistance. Research on AI tutoring illustrates why these are different questions.
Study online or in Kisii
See the fees, requirements and application process for your preferred study option.
Online
Join scheduled teaching, work with other students and receive instructor feedback from your own workspace.
Online fees and requirementsOnsite in Kisii
Learn at our Nyamarambe campus, with instructors nearby and other students working alongside you.
Onsite fees and requirements