IT & Computing Microcourses
A map of the full IT field, from computing foundations and software engineering to AI agents, cloud, security and specialized computing. Each area leads to one outcome you can demonstrate, not a list of buzzwords. This is the full scope of the field; courses will be produced in stages, not all at once.
100 topic areas across 20 groups. Each one is drafted as a single microcourse: concept → framework → practical workflow → one deliverable → how to measure it.
These are roadmap drafts, not produced courses. Durations, prices and launch dates will be set once a course is actually recorded. Any case studies used in a course will be labelled as illustrative examples.
Each area also has a free webinar topic you can vote for
1. Computer & Digital Fundamentals
Decode Binary, Hex and Unicode by Hand
Problem: Garbled text and file errors are mysterious because data representation was never understood.
A worked set of binary/hex/UTF-8 conversions and a fixed text-encoding bug.
Frameworks: Big-O Complexity Analysis · Computational Thinking · Worked Problem Sets
Measured by: Correctness on test cases · Time and space complexity · Problems solved independently
2. Mathematics & Statistics for Computing
Apply Probability and Statistics to a Real Dataset
Problem: Developers avoid maths-heavy topics like ML and performance analysis because the basics feel shaky.
A notebook applying descriptive statistics, probability and one hypothesis test to real data.
Frameworks: Big-O Complexity Analysis · Computational Thinking · Worked Problem Sets
Measured by: Correctness on test cases · Time and space complexity · Problems solved independently
3. Data Structures & Algorithms
Choose the Right Data Structure and Prove Its Complexity
Problem: Code works on small inputs but slows to a crawl on real data because of the wrong data structure.
A before/after refactor with complexity analysis and a benchmark on growing inputs.
Frameworks: Big-O Complexity Analysis · Computational Thinking · Worked Problem Sets
Measured by: Correctness on test cases · Time and space complexity · Problems solved independently
4. Theory of Computation
Build a Regex and Its Finite Automaton
Problem: Regular expressions are copied blindly and NP-hard problems are attacked with brute force.
A finite automaton for a validation rule, its regex and an NP-hard problem approximation note.
Frameworks: Big-O Complexity Analysis · Computational Thinking · Worked Problem Sets
Measured by: Correctness on test cases · Time and space complexity · Problems solved independently
5. Computer Architecture & Organization
Measure Cache Effects on Your Own Code
Problem: Performance surprises can't be explained without understanding caches and memory layout.
A benchmark showing cache-friendly vs cache-hostile access patterns with an explanation.
Frameworks: Big-O Complexity Analysis · Computational Thinking · Worked Problem Sets
Measured by: Correctness on test cases · Time and space complexity · Problems solved independently
6. Programming Fundamentals
Build a Validated Command-Line Tool from Scratch
Problem: Beginners copy tutorials but can't break a new problem into code on their own.
A small CLI program with functions, input validation, error handling and file I/O.
Frameworks: Problem Decomposition · Read–Run–Modify Practice · Debugging Method (reproduce, isolate, fix, verify)
Measured by: Working programs · Bugs found before review · Time to diagnose a failure
7. Programming Paradigms & Type Systems
Solve One Problem in Three Paradigms
Problem: Developers force every problem into one style and fight the type system instead of using it.
Procedural, OOP and functional solutions to one problem with a typed comparison note.
Frameworks: Problem Decomposition · Read–Run–Modify Practice · Debugging Method (reproduce, isolate, fix, verify)
Measured by: Working programs · Bugs found before review · Time to diagnose a failure
8. Compilers, Interpreters & Language Runtimes
Build a Tiny Expression Interpreter
Problem: Runtime behaviour like garbage-collection pauses and JIT warm-up feels like magic.
A tokenizer, parser, AST and evaluator for a mini expression language.
Frameworks: Problem Decomposition · Read–Run–Modify Practice · Debugging Method (reproduce, isolate, fix, verify)
Measured by: Working programs · Bugs found before review · Time to diagnose a failure
9. Operating Systems & Concurrent Programming
Reproduce and Fix a Race Condition
Problem: Intermittent bugs appear under load because shared state isn't synchronized.
A reproducible race-condition demo, a correct fix and a deadlock-avoidance note.
Frameworks: Problem Decomposition · Read–Run–Modify Practice · Debugging Method (reproduce, isolate, fix, verify)
Measured by: Working programs · Bugs found before review · Time to diagnose a failure
10. Developer Tools & Collaboration
Set Up a Reproducible Project with Scripts and a Debugger
Problem: "Works on my machine" problems waste hours because environments aren't reproducible.
A repository with pinned dependencies, setup scripts, debugger config and a PR template.
Frameworks: Problem Decomposition · Read–Run–Modify Practice · Debugging Method (reproduce, isolate, fix, verify)
Measured by: Working programs · Bugs found before review · Time to diagnose a failure
11. Requirements Engineering & Software Lifecycle
Turn a Vague Request into Stories with Acceptance Criteria
Problem: Features get rebuilt because the requirement was misunderstood from the start.
User stories with Given–When–Then criteria, non-functional requirements and an estimate.
Frameworks: Test Pyramid · SOLID Principles · Acceptance Criteria (Given–When–Then)
Measured by: Defect escape rate · Test reliability (flaky-test rate) · Change failure rate
12. Software Design & Code Quality
Refactor a Code Smell Using SOLID
Problem: Every change breaks something else because modules are tightly coupled.
A refactored module with lower coupling, a pattern applied and tests proving behaviour is unchanged.
Frameworks: Test Pyramid · SOLID Principles · Acceptance Criteria (Given–When–Then)
Measured by: Defect escape rate · Test reliability (flaky-test rate) · Change failure rate
13. Software Testing & Quality Assurance
Build a Test Pyramid for One Feature
Problem: Tests are either missing or so flaky that the team ignores failures.
Unit, integration and one end-to-end test for a feature, plus a flaky-test fix.
Frameworks: Test Pyramid · SOLID Principles · Acceptance Criteria (Given–When–Then)
Measured by: Defect escape rate · Test reliability (flaky-test rate) · Change failure rate
14. Formal Methods & Software Verification
Add Contracts and Invariants to Critical Code
Problem: Critical logic is trusted on testing alone, missing edge cases no test thought of.
Pre/postconditions and invariants on a critical function plus a static-analysis report.
Frameworks: Test Pyramid · SOLID Principles · Acceptance Criteria (Given–When–Then)
Measured by: Defect escape rate · Test reliability (flaky-test rate) · Change failure rate
15. Maintenance, Reverse Engineering & Modernization
Pin Legacy Behaviour with Characterization Tests
Problem: Nobody dares change the old system because nobody knows what it really does.
A dependency map, characterization tests and a strangler-style replacement plan.
Frameworks: Test Pyramid · SOLID Principles · Acceptance Criteria (Given–When–Then)
Measured by: Defect escape rate · Test reliability (flaky-test rate) · Change failure rate
16. Web & Browser Fundamentals
Trace a Page Load in Browser DevTools
Problem: CORS errors, cookie issues and slow pages are fixed by trial and error.
An annotated network and rendering trace plus a fixed cross-origin request.
Frameworks: Core Web Vitals · WCAG Principles (POUR) · Component-Driven Design
Measured by: Largest Contentful Paint · Interaction to Next Paint · Accessibility issues
17. Frontend Application Engineering
Build a Form with Validation, Loading and Error States
Problem: UIs show blank screens and stale data because loading and error states were skipped.
A routed page with validated form, data fetching and complete loading/empty/error states.
Frameworks: Core Web Vitals · WCAG Principles (POUR) · Component-Driven Design
Measured by: Largest Contentful Paint · Interaction to Next Paint · Accessibility issues
18. UI, UX & Human-Computer Interaction
Prototype a Flow and Run a Five-User Usability Test
Problem: Features are technically correct but users can't figure out how to use them.
A wireframe prototype, usability-test script, findings and prioritized UI fixes.
Frameworks: Core Web Vitals · WCAG Principles (POUR) · Component-Driven Design
Measured by: Largest Contentful Paint · Interaction to Next Paint · Accessibility issues
19. Accessibility & Internationalization
Fix a Page for Keyboard, Screen Reader and Hindi Locale
Problem: Interfaces exclude keyboard and screen-reader users and break in other languages.
An accessibility audit with fixes and a page localized with proper date/number formatting.
Frameworks: Core Web Vitals · WCAG Principles (POUR) · Component-Driven Design
Measured by: Largest Contentful Paint · Interaction to Next Paint · Accessibility issues
20. Web Performance & Discoverability
Hit a Performance Budget on One Page
Problem: Pages feel slow on phones and rank poorly because performance was never measured.
A performance budget, before/after Core Web Vitals and metadata/structured-data fixes.
Frameworks: Core Web Vitals · WCAG Principles (POUR) · Component-Driven Design
Measured by: Largest Contentful Paint · Interaction to Next Paint · Accessibility issues
21. Backend Application Engineering
Structure a Backend Service in Clear Layers
Problem: Business logic, SQL and HTTP handling are mixed together, making changes risky.
A layered service (routes, services, repositories) with validation and consistent errors.
Frameworks: OpenAPI Contracts · Twelve-Factor App · OAuth 2.0 / OpenID Connect
Measured by: Error rate · p95 latency · Contract-test pass rate
22. API Engineering
Build an Idempotent, Paginated API with OpenAPI
Problem: Retries create duplicate orders and API changes break existing clients.
An OpenAPI contract, idempotency keys, pagination and a backward-compatible version change.
Frameworks: OpenAPI Contracts · Twelve-Factor App · OAuth 2.0 / OpenID Connect
Measured by: Error rate · p95 latency · Contract-test pass rate
23. Application Identity & Access
Implement Role-Based Access with Tenant Boundaries
Problem: Users can see other customers' data because authorization checks are missing or inconsistent.
Login with sessions or tokens, RBAC checks, tenant isolation tests and a recovery flow.
Frameworks: OpenAPI Contracts · Twelve-Factor App · OAuth 2.0 / OpenID Connect
Measured by: Error rate · p95 latency · Contract-test pass rate
24. Real-Time & Asynchronous Applications
Add Live Progress Updates to a Background Job
Problem: Long tasks time out requests and users have no idea whether work is progressing.
A queued job with retries, cancellation and live progress via SSE or WebSockets.
Frameworks: OpenAPI Contracts · Twelve-Factor App · OAuth 2.0 / OpenID Connect
Measured by: Error rate · p95 latency · Contract-test pass rate