16 Weeks To
Production.
A no-bs engineering program covering software foundations, Linux, databases, backend APIs, frontend architecture, security and deployment.
Foundations & Systems
Weeks 1–4
Week 01
Software Engineering Foundations
Understand how the modern web actually works before writing a single line of code.
How the Internet Works
Understand the journey a request takes from browser to server and back.
HTTP & HTTPS
Learn the protocol that powers every web application and why encryption matters.
DNS & Domains
See how domain names resolve to IP addresses and how DNS records are structured.
Client vs Server
Understand the fundamental split between what runs in the browser and what runs on the server.
APIs
Learn what APIs are, how they work, and why every modern application depends on them.
Databases
Get a conceptual introduction to how data is stored, structured and queried.
Authentication
Understand sessions, tokens and how identity verification works at a high level.
Debugging
Build a mental model for finding and fixing problems systematically.
Week 02
Linux Fundamentals
Master the Linux terminal — the core skill every backend and DevOps engineer must have.
Linux Filesystem
Navigate the Linux directory tree and understand how files and folders are organised.
Terminal Navigation
Move around, read files, and execute commands entirely from the command line.
SSH
Connect to remote servers securely and manage them without a graphical interface.
Package Management
Install, update and remove software using APT and understand package repositories.
Users & Groups
Create and manage users and groups to control who has access to what.
Permissions
Understand read, write and execute permissions and how they protect system files.
File Ownership
Learn how ownership is assigned and how to change it safely.
Process Management
Monitor, control and kill running processes using ps, top and kill.
Week 03
Networking Fundamentals
Learn how data flows across networks and how servers communicate with each other.
DNS Records
Understand A, CNAME, MX and TXT records and how to configure them.
TCP vs UDP
Learn the difference between reliable and fast transport protocols and when each is used.
Ports
Understand port numbers and how services listen on specific ports.
Reverse Proxy
See how Nginx acts as a middleman to route traffic to backend services.
SSL/TLS
Understand how encrypted connections are established using certificates.
Server Architecture
Learn how web servers, application servers and databases are structured together.
Nginx Basics
Write basic Nginx configuration files to serve static content and proxy requests.
Week 04
Database Engineering
Design robust databases and write real SQL to store and retrieve data efficiently.
SQL vs NoSQL
Understand when to use relational databases vs document stores and why.
Database Design
Model real-world data using entities, relationships and normalisation principles.
Primary Keys
Learn how primary keys uniquely identify rows and why every table needs one.
Foreign Keys
Link tables together with foreign key constraints to enforce data integrity.
Indexes
Speed up queries dramatically by understanding how indexes work under the hood.
Joins
Combine data from multiple tables using INNER, LEFT and RIGHT joins.
Transactions
Ensure data consistency by grouping operations into atomic transactions.
PostgreSQL
Set up and query a production-grade PostgreSQL database from the terminal.
Backend Engineering
Weeks 5–8
Week 05
Python Engineering
Write clean, typed and professional Python code the way real engineers do.
OOP
Design reusable classes, inheritance hierarchies and encapsulated Python objects.
Type Hints
Add static type annotations to your code for better tooling and fewer bugs.
Dataclasses
Create lightweight data models using Python's built-in dataclass decorator.
Error Handling
Use try/except, custom exceptions and context managers to handle failures gracefully.
Virtual Environments
Isolate project dependencies using venv and pip to avoid version conflicts.
Testing
Write unit tests with pytest and understand test-driven development basics.
Week 06
Django Fundamentals
Build the backbone of your backend application using Django's powerful framework.
Architecture
Understand the MTV pattern and how models, views and templates work together.
Models
Define your database schema in Python and let Django manage migrations.
ORM
Query your database using Django's object-relational mapper instead of raw SQL.
Views
Handle HTTP requests and return responses using function-based and class-based views.
Admin Panel
Use Django's built-in admin interface to manage data without writing any frontend.
Authentication
Implement login, logout and registration using Django's built-in auth system.
Week 07
Django REST Framework
Build production-ready APIs that frontend applications and mobile apps can consume.
Serializers
Convert complex Django model instances to JSON and validate incoming request data.
ViewSets
Build CRUD endpoints rapidly using DRF's powerful ViewSet and Router system.
Permissions
Control who can access which endpoints using IsAuthenticated and custom permission classes.
Pagination
Handle large datasets by returning results in pages instead of all at once.
Filtering
Let API consumers search and filter results using query parameters.
Validation
Enforce data rules at the serializer level to keep your database clean.
API Design
Learn REST conventions, HTTP verbs, status codes and how to version APIs.
Week 08
Auth & Security
Implement secure, stateless authentication that works across any client application.
Sessions
Understand how traditional session-based authentication stores state on the server.
Cookies
Learn how browsers store and send cookies with every request automatically.
JWT
Implement JSON Web Token authentication for stateless, scalable APIs.
Access Tokens
Issue short-lived tokens that grant access to protected API endpoints.
Refresh Tokens
Issue long-lived tokens that allow users to get new access tokens without re-logging in.
Token Rotation
Rotate refresh tokens on every use to detect theft and limit exposure.
CSRF & XSS
Understand these attacks and how Django's middleware and sanitisation prevents them.
CORS
Configure cross-origin resource sharing so your frontend can safely call your API.
Frontend Engineering
Weeks 9–12
Week 09
Modern JavaScript
Master the language features every React and Next.js developer relies on daily.
ES6+
Use destructuring, spread, template literals and optional chaining in your code.
Modules
Organise code into reusable modules using import and export syntax.
Async/Await
Write asynchronous code that reads like synchronous code using async functions.
Fetch API
Make HTTP requests directly from the browser to load and send data.
Browser APIs
Access localStorage, the URL API and other browser-native capabilities.
Week 10
React Fundamentals
Build dynamic user interfaces with React's component model and state management.
Components
Break UIs into reusable, composable components that accept props and render JSX.
State
Manage local UI state with useState and understand when components re-render.
Hooks
Use useEffect, useRef and custom hooks to handle side effects and share logic.
Context API
Share state across the component tree without prop drilling using React Context.
Forms
Build controlled forms, handle validation and manage user input with React.
Week 11
Next.js Framework
Build production-ready web applications with the most popular React framework.
App Router
Use Next.js 13+ file-based routing to build pages, layouts and nested routes.
Server Components
Render components on the server for faster page loads and better SEO.
Client Components
Use the 'use client' directive for interactive components that need browser APIs.
SEO & Metadata
Implement metadata, Open Graph tags and dynamic titles for search visibility.
Performance
Optimise images, fonts and bundles to achieve high Lighthouse scores.
Week 12
Full Stack Integration
Connect your Django API and Next.js frontend into a complete, working application.
Django + Next.js
Configure CORS and connect a Next.js frontend to a Django REST API.
Protected Routes
Redirect unauthenticated users using middleware and server-side session checks.
Auth Flow
Implement login, signup, token storage and refresh logic end-to-end.
API Integration
Fetch data from your backend, handle loading states and display it in the UI.
Error Handling
Handle 401s, 404s and server errors gracefully with clear user feedback.
Production Engineering
Weeks 13–16
Week 13
VPS & Administration
Provision and harden a real Ubuntu server the way professional engineers do.
Ubuntu Server
Provision a fresh Ubuntu VPS on a cloud provider and configure it from scratch.
SSH Keys
Generate key pairs and configure SSH to use public key authentication instead of passwords.
SSH Hardening
Disable password login and apply security configurations to the SSH daemon.
Security Setup
Move SSH off the default port 22 and prevent direct root access.
UFW Firewall
Configure Uncomplicated Firewall rules to allow only the ports your application needs.
Fail2Ban
Automatically ban IP addresses that repeatedly fail authentication attempts.
Week 14
Deployment Workflows
Deploy your full stack application to a real server and serve it over HTTPS.
Gunicorn
Run your Django application using a production-grade WSGI server instead of runserver.
Nginx
Configure Nginx to proxy requests from port 80 to Gunicorn on a Unix socket.
Static Files
Collect and serve Django static files through Nginx for maximum performance.
Media Files
Configure a secure media file serving location and restrict direct access.
Environment Variables
Store secrets in .env files and load them safely using python-decouple.
SSL & Let's Encrypt
Automate free SSL certificate issuance and renewal with Certbot.
Week 15
Security & Operations
Harden your production environment against real-world attacks and failures.
SQL Injection
Understand how attackers manipulate queries and how Django's ORM prevents injection.
XSS & CSRF
Sanitise user input, set CSP headers and configure middleware to protect endpoints.
Security Headers
Set HTTP security headers like HSTS, X-Frame-Options and X-Content-Type-Options.
Logging
Configure Django and Nginx logging so you have an audit trail of all requests and errors.
Monitoring
Set up basic uptime monitoring and receive alerts when your service goes down.
Backups
Automate daily PostgreSQL database backups and store them off-server.
Week 16
Capstone SaaS Project
Build and deploy a complete SaaS application using everything you've learned.
Authentication
Implement full JWT auth with access tokens, refresh tokens and email verification.
Dashboard
Build a protected user dashboard that displays real user data from the API.
File Uploads
Handle file uploads on both the Django backend and Next.js frontend securely.
Email Verification
Send transactional emails with account confirmation links using Django and SMTP.
WebSockets
Add realtime communication to your application using Django Channels.
Realtime Notifications
Push live notifications to connected clients without page refreshes.
Deployment
Deploy the complete full stack application to production with SSL, Nginx and Gunicorn.
What You Will Achieve
By the end of this 16-week journey, you will have mastered:
Design Relational Databases
Model real-world data and write production SQL.
Build Scalable Django APIs
Build REST APIs with DRF, permissions and serializers.
Implement JWT Authentication
Handle auth end-to-end with tokens and refresh logic.
Work With WebSockets
Push realtime data to clients using Django Channels.
Build Next.js Applications
Build fast, SEO-friendly frontends with the App Router.
Configure Linux Servers
Set up, secure and manage Ubuntu VPS instances.
Secure VPS Infrastructure
Harden servers with firewalls, Fail2Ban and SSH rules.
Configure Nginx & SSL
Proxy traffic and serve your app over HTTPS.
Deploy Production Apps
Go from code to live URL with Gunicorn and Nginx.
Prevent Common Attacks
Understand and stop SQLi, XSS, CSRF and more.
Automate Backups
Schedule automated PostgreSQL backups off-server.
Think Like An Engineer
Approach problems with structure and discipline.