Skip to main content

AI Software Engineering Track

Monitors and a laptop

Goal​

Build production-grade, scalable systems. Learn the architecture patterns, tools, and practices that distinguish hobby projects from enterprise software.

1. Networking Fundamentals​

Core Concepts​

course
intermediate

Computer Networking Course

8-10 hours

Alternatively, complete the full Systems & Networking module for deeper understanding.

Understand how data travels to debug and optimize effectively.

Key Topics:

  • OSI Model: Layers 3-7 (Network to Application).
  • Protocols: TCP/IP, DNS, HTTP/HTTPS.
  • Performance: Load balancing, CDNs, SSL/TLS.

The TCP/IP Model​

video
beginner

TCP/IP vs OSI Models

30-45 minutes

The mental framework for debugging. If you can't connect, check the layers from bottom to top.

  1. Link Layer: Physical hardware (Ethernet, WiFi).
  2. Internet Layer: Routing across networks (IP addresses).
  3. Transport Layer: Reliable delivery (TCP) or fast streaming (UDP).
  4. Application Layer: User-facing protocols (HTTP, SSH).

TCP/IP in Practice​

video
intermediate

Real-World TCP/IP

30-45 minutes
  • TCP Handshake: SYN, SYN-ACK, ACK. Ensures reliable connections (used by HTTP/Web).
  • UDP: "Fire and forget". Faster but less reliable (used for video streaming).

Action Items:

  1. Watch videos on OSI model and HTTP.
  2. Use ping, traceroute, and curl to trace requests.
  3. Analyze a website's traffic using Browser DevTools.
  4. Memorize the 4 layers of the TCP/IP model.
  5. Use Wireshark (optional) to observe a TCP handshake in real-time.

2. Architecture Principles​

Core Concepts​

article
beginner

The Twelve-Factor App

2-3 hours
book
intermediate

Beyond the Twelve-Factor App

6-8 hours

Learn the battle-tested patterns that make applications scalable, maintainable, and cloud-ready.

Key Topics:

  • 12-Factor App: Config, Backing Services, Disposability, Dev/Prod Parity.
  • Cloud-Native: API-first design, Telemetry, Authentication strategies.
  • Scalability: Stateless processes, Horizontal scaling.

Action Items:

  1. Read the 12-Factor App methodology.
  2. Audit a previous project against the 12 factors.
  3. Draft an architecture document for a new service.

3. API Design & Implementation​

Core Concepts​

guide
beginner

REST API Tutorial

2-3 hours
tutorial
intermediate

FastAPI Official Tutorial

4-6 hours

Master RESTful API design and build high-performance endpoints using modern Python frameworks.

Key Topics:

  • REST: Resources, HTTP Methods, Status Codes, Versioning.
  • FastAPI: Path operations, Pydantic models, Async endpoints.
  • Documentation: Automatic OpenAPI (Swagger UI) generation.

Action Items:

  1. Design a REST API schema for a blog or library.
  2. Build a CRUD API using FastAPI with Pydantic validation.
  3. Implement JWT authentication and error handling.

4. Database Design & Management​

Core Concepts​

tutorial
beginner

SQLBolt

3-4 hours
docs
intermediate

Alembic Tutorial

2-3 hours

Design efficient schemas and manage data integrity.

Key Topics:

  • Design: ERD, Normalization (1NF-3NF), Indexing.
  • SQL: Joins, Transactions, ACID properties.
  • Migrations: Version control for database schemas.

Action Items:

  1. Create an ERD for an e-commerce system.
  2. Implement the schema in PostgreSQL and write complex queries.
  3. Set up Alembic for automated migrations.

5. Testing Strategies​

Core Concepts​

docs
intermediate

pytest Documentation

3-4 hours
tutorial
intermediate

FastAPI Testing Tutorial

1-2 hours

Write automated tests to catch bugs early and refactor with confidence.

Key Topics:

  • Types: Unit, Integration, End-to-End.
  • Tools: pytest fixtures, mocking, coverage reports.
  • TDD: Writing tests before implementation.

Action Items:

  1. Write unit tests for all API endpoints.
  2. Achieve 80%+ code coverage.
  3. Configure tests to run on every commit.

6. DevOps & Deployment​

Core Concepts​

docs
intermediate

GitHub Actions Documentation

3-4 hours
docs
intermediate

Docker Compose Documentation

2-3 hours

Automate deployment and ensure reproducibility with containers.

Key Topics:

  • CI/CD: Automated testing, linting, and deployment pipelines.
  • Docker: Containerizing applications for consistency.
  • Orchestration: Managing multi-container apps with Docker Compose.

Action Items:

  1. Create a GitHub Actions workflow to run tests on PRs.
  2. Containerize the FastAPI app and database.
  3. Deploy the stack using Docker Compose.

7. Specialization (Choose One)​

Option A: Mobile Development (Flutter/Swift)​

tutorial
beginner

Flutter Codelabs

6-8 hours

Goal: Build a mobile app consuming your API. Key Topics: Widgets, State Management, API Integration.

Option B: Full-Stack Web (React/Vue)​

tutorial
beginner

React Tutorial

4-6 hours
guide
beginner

Vue Guide

3-4 hours

Goal: Build a responsive web app consuming your API. Key Topics: Components, Hooks/Composition API, Routing.

Note: For deeper integration and deployment practices, see the Infra Basics module.

Project Requirement:

  • Implement a frontend (Mobile or Web) for your API.
  • Include authentication and data visualization.

Capstone Project​

Build a full-stack production application with microservices, databases, containerization, CI/CD, and a frontend.

Track Completion Checklist​

  • Explain HTTP request lifecycle.
  • Design scalable REST APIs (12-factor).
  • Normalize database schemas (3NF).
  • Write complex SQL queries.
  • Achieve 80%+ test coverage.
  • Deploy with Docker Compose and CI/CD.
  • Build a full-stack application.

Support & Resources​

Channels: #software-arch, #backend-dev, #devops-help Office Hours: Wednesdays 3-6 PM

Next Steps:

guide
advanced

System Design Primer

8-10 hours
  • Cloud Certifications (AWS/GCP)
  • Technical Interview Prep