LuxDevHQ logoLuxDevHQ

LuxDevHQ School of Software Engineering

Technology Is Moving Fast.
Are Your Skills Ready?

Build the practical software engineering skills, portfolio, and confidence you need to go from your first line of code to designing, building, and shipping full-stack applications.

10 months • 10+ real projects • Python-first • Full-stack

Explore the Learning Journey
portfolio-api / main.py
01
02
03
04
05
06
from fastapi import FastAPI
from database import projects

app = FastAPI()

@app.get("/projects")
async def get_projects():
    return projects
main*Python 3.12
terminal

➜ git push origin main
✓ deployed successfully

portfolio-apiPUBLIC

12 commits · tests passing

GET /projects 200 OK

10 Months

Complete learning journey

10+ Projects

Built for your portfolio

Python First

Strong programming foundation

Full Stack

Frontend + backend

GitHub Portfolio

Graduate with evidence

Practical capability

Build Skills You Can Actually Use

Knowing syntax isn't enough. Software engineers take an idea, break it into problems, work with databases and APIs, test their applications, and ship working software. That's what this program is designed to teach.

Build Software From Scratch

Turn ideas into structured, working applications.

Develop Backend Applications

Build APIs and services using Python, FastAPI, SQL and relational databases.

Build Modern Frontends

Create responsive interfaces using HTML, CSS, JavaScript, React and Next.js.

Work Like an Engineer

Use Git, GitHub, terminals, branches, environments and professional workflows.

Solve Problems Systematically

Develop algorithmic thinking and understand data structures, complexity and performance.

Ship What You Build

Learn testing, debugging, deployment and CI/CD fundamentals.

Learn by building

Don't Just Learn Software Engineering. Build Software.

Every major stage produces something you can demonstrate.

Not another set of notes. Not another tutorial you followed.

Something you built.

10+

GitHub Projects

01

Full-Stack Capstone

Your

Developer Portfolio

Project roadmap

Ten Projects. One Clear Progression.

Each build introduces more complexity, more independence, and stronger evidence of what you can do.

01

CLI Application

Python / Git / GitHub

02

Core Python Application

Python / Files / Modules

03

Python + Scala OOP Project

Python / Scala / OOP

04

Interactive JavaScript Application

HTML / CSS / JavaScript

05

Data Structures & Algorithms Library

Python / Algorithms / Big-O

06

Database-Powered Application

SQL / PostgreSQL / HTTP

07

Production REST API

FastAPI / REST / Testing

08

React Application

React / Routing / APIs

09

Full-Stack Next.js Application

Next.js / Auth / Deployment

10

Graduate Capstone

Architecture / CI/CD / Portfolio

Technology stack

Python First. Full-Stack Ready.

Python forms the programming foundation, then students expand into the technologies required to build complete modern applications.

Programming

Python • Scala • JavaScript

Frontend

HTML • CSS • ReactJS • Next.js

Backend

Python • FastAPI • REST APIs

Data

SQL • PostgreSQL • Relational Databases

Developer Tools

Git • GitHub • VS Code • Terminal • Linux

Engineering

Testing • Debugging • Algorithms • Deployment • CI/CD

10-month learning journey

From First Principles to Full-Stack Engineering

JavaScript fundamentals come before the dedicated algorithms module, so you gain practical experience before formalizing the computer-science foundations.

  • Operating system and development setup
  • Terminal / command line and VS Code
  • Package managers, virtual environments and dependency management
  • Git and GitHub: repositories, commits and branches
  • How programs run
  • Python variables, data types and operators
  • Input and output

Build

Professional development environment + first command-line application pushed to GitHub.

Project-driven learning

Build Real Software Systems

Throughout the program, students move beyond isolated exercises and build increasingly complex systems combining frontend and backend engineering, databases, authentication, real-time communication, caching, testing, deployment and system design.

Each project asks you to design the architecture, model data, build APIs, implement business rules, test, containerize, document decisions and deploy working software.

PROJECT 01Guided · Foundation

Real-Time Collaboration Platform

Build a modern team communication platform inspired by products such as Microsoft Teams, Slack and Discord.

Design a multi-user system where organizations create workspaces, teams and channels, exchange messages and files, and manage access. The goal is not a visual clone—it is understanding the engineering behind connected collaboration systems.

What you will build

  • Authentication & workspaces
  • Public/private channels
  • Direct & group messaging
  • Threads, reactions & files
  • Presence & typing indicators
  • Read receipts & notifications
  • Multi-device sync
  • RBAC & admin controls

Engineering concepts

  • REST APIs
  • WebSockets
  • Redis Pub/Sub
  • Relational modeling
  • Idempotency
  • Optimistic concurrency
  • Event-driven architecture
  • Background processing

Technology stack

Next.jsTypeScriptFastAPIPostgreSQLRedisMinIO / S3DockerPytestCI/CD

System architecture

Clients
Next.js
FastAPI
PostgreSQL + Redis
WebSockets + Workers

Project outcome

A working multi-user collaboration system—and a practical understanding of how messaging platforms maintain state across connected devices.

PROJECT 02Intermediate · Workflows

Real-Time Food Delivery Platform

Design the backend and operational systems behind a modern food delivery application.

Build the business logic behind a delivery platform where customers, restaurants and riders interact with the same order in real time. The engineering focus is state, transactions and operations—not merely displaying menus.

What you will build

  • Customer ordering & history
  • Restaurant and menu tools
  • Acceptance & preparation flow
  • Rider availability & assignment
  • Pickup and delivery workflow
  • Live location updates
  • Payments & notifications
  • Admin and role analytics

Engineering concepts

  • State machines
  • Transactions
  • RBAC
  • Payment idempotency
  • WebSockets
  • Geospatial thinking
  • Queues & workers
  • Caching & analytics

Technology stack

Next.jsFastAPIPostgreSQLRedisWebSocketsCelery / DramatiqMinIO / S3DockerGrafana

System architecture

Customer · Restaurant · Rider
FastAPI
PostgreSQL + Redis
Background Workers
Payments · Alerts · Analytics

Enforced lifecycle

PENDINGCONFIRMEDPREPARINGREADY FOR PICKUPRIDER ASSIGNEDPICKED UPOUT FOR DELIVERYDELIVERED

Invalid transitions, such as PENDING → DELIVERED, are rejected.

Project outcome

The ability to model complex business workflows where multiple actors safely update the same transaction in real time.

PROJECT 03Advanced · Operations

Real-Time Customer Support Platform

Build a customer support system inspired by products such as Intercom, Zendesk and Freshdesk.

Create a complete support operation where customers start conversations, agents respond live, tickets move between departments, queues are prioritized and administrators measure service performance.

What you will build

  • Customer conversation portal
  • Live agent workspace
  • Attachments & notifications
  • Internal notes & escalation
  • Ticket routing & statuses
  • Departments, roles & SLAs
  • Presence & read receipts
  • Service analytics

Engineering concepts

  • Queues & priority queues
  • Routing algorithms
  • WebSockets
  • Presence systems
  • Resource permissions
  • SLA tracking
  • Event-driven systems
  • Operational analytics

Technology stack

Next.jsFastAPIPostgreSQLRedisWebSocketsCelery / DramatiqDockerGrafana

System architecture

Customer + Agent
Real-time API
Ticket Router + Redis
Queues + Workers
SLA + Analytics

Enforced lifecycle

NEWWAITINGASSIGNEDIN PROGRESSWAITING FOR CUSTOMERESCALATEDRESOLVEDCLOSED

Project outcome

A production-style system—and an understanding of how real-time communication, queues, permissions, SLAs and analytics work together.

Queue

Waiting customers

Priority queue

Urgent tickets

Hash maps

Session lookups

Sets

Online agents

Circular queue

Round-robin

Trees

Categories

Graphs

Escalation paths

From applications to systems

Complexity is deliberate.

Technologies arrive when the engineering problem demands them—not because they appear in a list. Redis enters when shared state matters. Queues appear when work must be scheduled. Docker makes services consistent. CI/CD makes deployment repeatable.

  1. 01

    Collaboration Platform

    Messaging & synchronization

  2. 02

    Food Delivery Platform

    Transactions & multiple roles

  3. 03

    Customer Support Platform

    Queues, routing & SLAs

  4. 10

    Graduate Capstone

    Operate a production platform

Month 10 · Graduate capstone

Build and Operate a Production-Grade Digital Commerce Platform

Nexus Commerce

One platform. Multiple services. Real users. Production engineering.

Design a multi-tenant commerce and operations platform where independent businesses manage products, customers, orders, payments, inventory, staff and analytics. This is a complete production challenge—not a tutorial.

Every organization has isolated users, customers, products, inventory, orders, payments, analytics and staff permissions.

Lux Electronics · Acme Furniture · Nairobi Coffee Company

nexus-commerce / production

Clients + Next.js
FastAPI · Modular API
PostgreSQL · Redis · Object Storage
Task Queue · Background Workers
Logs · Metrics · Monitoring

Core product

One platform. Real operational depth.

Identity & organizations

Registration, sessions, invitations, roles, permissions and optional passkeys.

Products & inventory

Variants, warehouses, reorder alerts and an auditable stock-movement ledger.

Orders & payments

Enforced state transitions, asynchronous callbacks, retries, refunds and idempotency.

Live operations

Revenue, stock, transactions, failed payments and operational alerts in real time.

Notifications

Email, in-app and simulated SMS delivered through background workers.

Search & analytics

Indexes, pagination, filtering, query optimization and meaningful business metrics.

Architecture strategy

Begin with a modular monolith.

Identity, organizations, products, inventory, orders, payments, notifications and analytics begin as clear FastAPI modules. PostgreSQL, Redis and object storage support the core; task queues and workers are introduced for asynchronous work.

Good software architecture does not mean creating as many services as possible.

Kafka is an optional advanced extension. Students must justify when a component truly needs to become a separate service.

Architecture

Clean, reusable modules and justified design patterns

Security

Secure sessions, RBAC, rate limits and validated input

Reliability

Retries, idempotency, logging and graceful failure

Testing

Unit, integration, API and end-to-end coverage

DevOps

Docker, CI/CD, Linux, HTTPS and deployment

Observability

Health checks, metrics, dashboards and error monitoring

Capstone deliverables

Evidence of the complete process.

  1. 01GitHub repository
  2. 02Complete README
  3. 03Architecture diagram
  4. 04Database ER diagram
  5. 05API documentation
  6. 06Automated tests
  7. 07Docker setup
  8. 08CI/CD pipeline
  9. 09Deployed application
  10. 10Technical presentation
  11. 11Engineering decision document
  12. 12Project retrospective

Engineering decision document

Can you explain why the system was engineered this way?

Why this database structure—and which indexes?

Where do Redis and queues add value?

How do retries avoid duplicate payments or orders?

What if Redis is unavailable?

How are concurrent inventory updates handled?

How does resource-level authorization work?

What fails first at 100× traffic?

What changes before serving one million users?

The final assessment is not simply “Does it work?” Engineering means understanding trade-offs, anticipating failure and defending the decisions behind the build.

Graduate as an engineer who can move from an idea to architecture, implementation, testing, deployment and operation of a complete software system.

Project philosophy

You Do Not Graduate With Tutorials. You Graduate With Systems.

By the end of the program, you can receive an unfamiliar software problem, break it into components, model the data, design APIs, choose appropriate structures, implement security, handle failure, test, containerize, deploy and explain your architectural decisions.

Problem
Requirements
Architecture
Data model
APIs
Implementation
Testing
Deployment
Monitoring
Iteration

Ready to Build Like a Software Engineer?

Learn the fundamentals, build real systems and finish with the confidence to design software beyond tutorials.

Graduate portfolio

Your Work Should Speak Before You Do.

When someone asks what you can build, you should have something you can show: documented projects that demonstrate how you think, build and ship.

01

GitHub projects

02

REST APIs

03

Frontend applications

04

Databases

05

Full-stack applications

06

Graduate capstone

07

Technical documentation

08

Deployment evidence

Student stories

Real People. Real Projects. Real Career Progress.

Verified learner stories will show the full journey—not isolated quotes or unsubstantiated outcomes.

1

Starting Point

2

Challenge

3

What They Built

4

Skills Developed

5

Career Outcome

Stories are being documented. Student names, projects, portfolio links, quotes and outcomes will only appear here once they have been verified and approved for publication.

Who this is for

Start at the Foundation. Grow Into the Work.

No prior programming experience required. The course starts with fundamentals and progresses to serious full-stack engineering.

01Complete Beginners
02University Students
03Career Switchers
04Self-Taught Developers
05Working Professionals
06LuxDevHQ Data Science Alumni
07LuxDevHQ Data Analytics Alumni
08LuxDevHQ Data Engineering Alumni

Program investment

One Complete 10-Month Path

Instructor-led learning, hands-on practice and a body of work that grows with you.

Standard program

KSh 90,000

10 months

  • Instructor-led classes
  • Hands-on coding
  • 10+ portfolio projects
  • GitHub portfolio
  • Full-stack capstone
  • Career readiness
  • Future curriculum access

Already Part of LuxDevHQ?

40% OFF

For LuxDevHQ Data Science, Data Analytics and Data Engineering alumni.

  • Data Science alumni
  • Data Analytics alumni
  • Data Engineering alumni

Regular KSh 90,000

Alumni rate

KSh 54,000

Save KSh 36,000

Lifetime future access

Enroll Once. Keep Learning.

Technology changes. Graduates can attend future Software Engineering classes and receive Software Engineering curriculum updates without additional tuition. This supports continued learning and does not mean unlimited private tutoring.

FAQ

Questions, Answered.

Start building

Your Next Software Project Could Change Your Career.

Start With the First One.

Ten months from now, your GitHub can look very different. Instead of simply saying you're learning to code, point to applications you've designed, built and shipped.

Explore the Curriculum