ALCI AI Engineering Fellowship Program
A 15-Month, 5-Semester Full-Stack AI Engineering Program — fifteen subjects and five connected projects, from zero-level foundations to a supervised professional residency.
At a glance
- Duration
- 15 months · 5 semesters
- Commitment
- 20–25 hours per week
- ALCI credit hours
- 60 across 20 components
- After graduation
- Internship placement support
Credits and grading
Each of the fifteen subjects is worth 3 ALCI credit hours, and so is each Semester Project — 60 credit hours over 20 graded components. Semester GPA is the credit-weighted average of that semester’s three subjects and its project; CGPA runs across all five semesters on a 4.0 scale. To graduate you must pass every component and finish with a CGPA of at least 2.0.
Before you start
AI coding assistants are allowed and expected on mini-projects and semester projects — using them well is part of the job. They are banned in timed practical assessments. Every line you submit must be yours to explain: each project carries a 20-point live walkthrough in which you explain and modify any part of your own code. Work you cannot explain is capped at 50%, whoever or whatever wrote it.
The five semesters
Every subject is taught through projects, and each semester ends with one integrated project that needs all three of its subjects. The portfolio grows in one place: Semester 4 takes Semester 3’s product to production; Semester 5 then operates and improves it in a supervised residency while turning the evidence into a professional portfolio.
A guided path from opening a coding workspace and learning Python syntax to building tested data tools. No coding experience is assumed; the subject introduces programming before data engineering projects.
AI & Computing Foundations
A required, non-credit bridge before the three graded Semester One subjects. No external Python course is required; Python syntax begins at the start of AIEF-101.
- Foundation 1
Where Python fits in an AI project
- Foundation 2
Files, folders, terminal, and a project workspace
- Foundation 3
Data foundations: rows, columns, CSV, and data quality
- Foundation 4
Data tools preview: Pandas and NumPy
- Foundation 5
Math foundations: quantities, averages, and uncertainty
- Foundation 6
Web foundations: requests, JSON, and APIs
- Foundation 7
Build workflow: tests, Git, and reproducible results
Complete this foundation before the three graded Semester One subjects. No Python or AI experience is required; AIEF-101 begins Python from the basics.
AIEF-101
Python for AI Engineering
A beginner-friendly progression from the coding workspace and Python fundamentals to practical engineering: set up a project, work with small files and CSVs, inspect and clean data one rule at a time, debug and test changes, use Git, read JSON from an API, and turn the work into a reusable tool.
Start here · Beginner foundation
Python Engineering Foundations: files, inputs and outputs
Use the Python you already practised in Practice Lab to open a small project, run a starter script, and describe its input and output.
No prior AI experience needed · start with the foundation, then follow each lesson and its guided practice in order.
Feeds the project: Writes the data-cleaning and processing pipeline for Semester Project 1.
Beginner → intermediate → advanced · 21 lessons
- Meet the Python workspaceBeginnerOpen the editor or notebook, run a provided cell, and identify input, code, and output.
- Values, names, and outputBeginnerStore a number or short text in a variable and print a clear result.
- Types and safe conversionBeginnerDistinguish text, integers, decimals, and booleans; convert input only after checking it.
- Expressions and comparisonsBeginnerUse arithmetic and comparison operators to answer a small data question.
- Make decisions with if/elif/elseBeginnerWrite a branching rule and test both the expected and boundary cases.
- Repeat work with loopsBeginnerUse a loop to process a short list and explain how the loop stops.
- Lists and dictionariesBeginnerChoose a list for ordered items and a dictionary for named fields.
- Write and call functionsBeginnerTurn repeated logic into a small function with inputs, a return value, and a docstring.
- Read errors and debugBeginnerRead a traceback, locate the failing line, and fix one cause at a time.
- Files, folders, and pathsBeginnerUse a project folder and pathlib to locate input and output files reproducibly.
- Read and write text safelyBeginnerOpen a UTF-8 text file with a context manager and preserve the source file.
- CSV rows, headers, and recordsBeginnerLoad a tiny CSV and explain how headers and rows map to Python values.
- First Pandas DataFrameIntermediateInspect rows, shape, columns, and dtypes before changing a dataset.
- Select, filter, and summarize rowsIntermediateAnswer a concrete question with a DataFrame selection and a grouped summary.
- Clean text and missing valuesIntermediateApply one cleaning rule, count affected rows, and compare before and after.
- Duplicates and data-quality checksIntermediateDetect duplicate records and add assertions for the expected schema.
- NumPy arrays and shapesIntermediateCreate an array, inspect its shape and dtype, and compute a simple numeric summary.
- Test a function with pytestIntermediateTest a normal input, an edge case, and a clearly defined cleaning rule.
- Modules, virtual environments, and READMEAdvancedSeparate reusable code, record setup steps, and run the project in an isolated environment.
- Git: inspect and record a changeAdvancedReview status and a diff, then create a small commit with a useful message.
- REST, JSON, and resilient requestsAdvancedRead named fields from a small API response and handle missing data or a failed request.
Apply the concepts · 3 mini-projects
- Messy-data cleanerStart with a teacher-provided CSV of 100–500 rows containing a few clearly identified issues. Build a small script that inspects the data, applies one cleaning rule at a time, reports changed rows, and has tests for normal and edge cases. After the first version works, try a larger file and additional issue types as an extension.
- API collectorRead a small public JSON API response, identify its fields, save selected records, and handle a missing field or failed request clearly. Pagination, retry limits, caching and structured logs are extension milestones after the basic request works.
- Text toolkitTurn one useful function from the semester into a documented, reusable Python module. Add examples and tests; package installation and English/Urdu text handling are extension goals once the module is reliable.
AIEF-102
Math & Statistics for Machine Learning
Build mathematical confidence step by step: read tables and charts, compare counts and averages, understand spread and simple probability, then reason about samples and uncertainty. Vectors, similarity and a visual introduction to model learning come after these foundations; no calculus is assumed at the start.
Start here · Beginner foundation
Math Foundations: numbers, tables and uncertainty
Read a small dataset, compare counts and averages, and explain why a sample can mislead.
No prior AI experience needed · start with the foundation, then follow each lesson and its guided practice in order.
Feeds the project: Builds the statistics and insights module for Semester Project 1.
Beginner → intermediate → advanced · 21 lessons
- Numbers, units, and estimationBeginnerRead a quantity with its unit and estimate whether an answer is plausible.
- Read tables and chartsBeginnerIdentify what a row represents and describe a simple chart without jumping to conclusions.
- Counts, fractions, ratios, and ratesBeginnerCompare groups of different sizes using an appropriate denominator.
- Mean, median, and modeBeginnerCalculate common averages and choose one that represents the question fairly.
- Range, quartiles, and unusual valuesBeginnerDescribe spread and explain how an outlier can change a summary.
- Distributions and histogramsBeginnerRead the shape and scale of a distribution before comparing two results.
- Probability as long-run frequencyBeginnerEstimate simple event probabilities and distinguish likelihood from certainty.
- Conditional probability basicsBeginnerUse a small two-way table to interpret a probability conditioned on a group.
- Population, sample, and samplingBeginnerDistinguish the population from the observed sample and explain what was measured.
- Sampling bias and data leakageBeginnerSpot a biased sample and explain why leaked information makes an evaluation untrustworthy.
- Compare groups fairlyBeginnerCompare group sizes and summaries while separating association from causation.
- Variation and uncertaintyBeginnerExplain why repeated samples can give different estimates of the same quantity.
- Confidence intervals in plain languageBeginnerInterpret an interval as uncertainty around an estimate, not a guarantee for an individual.
- Design a small A/B comparisonIntermediateState one measurable question, define groups, and choose a sensible outcome measure.
- Simulate repeated samplesIntermediateChange a sample or random seed and observe how an estimate varies.
- Coordinates and vectorsIntermediateRepresent a short set of measurements as a vector and calculate a component-wise difference.
- Distance, dot product, and directionIntermediateCompare tiny vectors visually before using a numerical similarity measure.
- Cosine similarity with guardrailsIntermediateCalculate cosine similarity and explain why vector direction and zero vectors matter.
- Predictions, residuals, and lossAdvancedCompare a prediction with an observed value and calculate a simple error.
- Follow a loss curveAdvancedRead a visual loss curve and describe whether a sequence of updates is improving.
- Learning rate and gradient-descent intuitionAdvancedChange a visual learning-rate control and explain overshooting versus slow progress.
Apply the concepts · 3 mini-projects
- Statistical profileUse a small guided dataset to count records, calculate mean and median, make one chart, and describe one unusual value. Add a larger dataset and a discussion of uncertainty as extensions.
- A/B test decisionCompare two small groups using a guided worksheet: state the question, show the group sizes, compare a simple average, and explain why the result alone cannot prove cause. Repeated simulation and confidence intervals are extensions.
- Gradient descent from scratchFollow a visual, provided one-variable example of a prediction improving as its error gets smaller. Students may change a learning-rate setting and describe the curve; implementing regression from scratch is an advanced extension.
AIEF-103
Full-Stack Web, Databases & APIs for AI
Build the complete application layer an AI engineer needs: HTTP and REST, FastAPI, validation, authentication, PostgreSQL and SQL, then HTML/CSS, JavaScript, TypeScript, React and Next.js. Connect a typed web interface to a tested Python service, handle loading and failure states, stream responses, protect secrets, containerise the system and deploy it.
Start here · Beginner foundation
Web Foundations: browser, server and data
Trace a request from a browser to a server and back, and identify where an API and database fit.
No prior AI experience needed · start with the foundation, then follow each lesson and its guided practice in order.
Feeds the project: Builds the API and database layer for Semester Project 1.
Beginner → intermediate → advanced · 21 lessons
- What the browser, server, and internet doBeginnerTrace a simple request from a browser to a server and back.
- URLs, DNS, and HTTP vocabularyBeginnerIdentify a URL, method, header, status code, and JSON body in a request/response.
- Build a semantic HTML pageBeginnerCreate a small accessible page using headings, labels, links, and form controls.
- Style a page with CSSBeginnerApply readable layout, spacing, and responsive styles without changing content structure.
- JavaScript values and objectsBeginnerRead and create simple values and objects used by a browser interface.
- Functions, modules, and async basicsBeginnerOrganize browser code into functions and explain when an asynchronous result arrives.
- Events, forms, and validationBeginnerRespond to a form event and show a helpful validation message.
- JSON and fetch from the browserBeginnerRequest a public sample, parse JSON, and show loading and failure states.
- REST routes and status codesBeginnerChoose a route and method and return a clear success or error status.
- Run a first FastAPI serviceIntermediateStart a local service and inspect a health route and its generated API documentation.
- Request models and validationIntermediateDefine a small Pydantic schema and reject invalid input with a useful response.
- Error handling and API testsIntermediateTest success, invalid input, and not-found behavior using isolated test data.
- Tables, keys, and relationshipsIntermediateModel a tiny relational dataset using primary keys and foreign keys.
- SQL select, filter, join, and groupIntermediateQuery a small database and explain the result of each clause.
- Connect an API to PostgreSQL safelyIntermediateUse parameterized queries and explain the purpose of a migration.
- Authentication, authorization, and secretsAdvancedProtect a route server-side and keep credentials out of browser code.
- React components, props, and stateAdvancedBuild a small interface from components and update it in response to user input.
- Next.js application structureAdvancedNavigate the App Router and distinguish server-only code from client interactions.
- Connect a typed UI to the APIAdvancedUse a shared response shape and handle success, loading, and error states end to end.
- Uploads and streamed responsesAdvancedExplain chunked output and design a UI that can cancel or recover from a partial response.
- Containers, deployment, and health checksAdvancedRun a containerized app locally, inspect health and logs, and document a safe release.
Apply the concepts · 3 mini-projects
- Dataset serviceBuild one guided route that returns a few records, then add one validated query and tests for a success and an invalid input. A database, pagination and broader coverage follow as extension steps.
- Keys and limitsAs a guided extension, protect one route with a development API key and explain why secrets belong in server configuration. Rate limiting and an audit log are stretch work.
- Long-running job endpointAs an advanced extension, trace a background task from request to status response. Streaming and Server-Sent Events are introduced conceptually; implementing a resilient job system is deferred to later study.
AIEF-SP1
Semester Project 1 - Full-Stack Data Intelligence Platform
A complete first product: upload and validate a real dataset, preserve the raw input, clean it reproducibly, calculate honest statistics, store records in PostgreSQL, expose a tested FastAPI service and present the results through an authenticated, accessible Next.js dashboard with clear loading and failure states.
Deliverables
- Reproducible Python pipeline cleaning a teacher-approved dataset with tests, change report and preserved raw input
- Statistics module and dashboard exposing at least 3 evidenced insights with plain-language uncertainty
- Authenticated FastAPI and PostgreSQL service with validation, authorization and tested success/failure paths
- Responsive Next.js and TypeScript interface with upload, filtering, charts, loading, empty and error states
- Containerised local stack plus a guided live deployment, architecture README and 5-minute demo video
- 15-minute live defence
Proves: Ships a tested, authenticated and deployed full-stack data product from raw input to user interface.
Classical baselines, deep models and vector search — with evaluation you can defend, whichever model wins.
AIEF-104
Machine Learning Fundamentals
Supervised learning (linear and logistic regression, trees, random forests, gradient boosting), feature engineering, splits and cross-validation and leakage, metrics (precision, recall, F1, ROC-AUC), class imbalance and thresholds, baselines and error analysis, experiment tracking, model serialisation, and scikit-learn pipelines.
Named topics and tools
- • Tabular and text baselines
- • Honest evaluation
- • Error analysis
Feeds the project: Builds the classical baseline model for Semester Project 2.
Detailed ordered topics (16)
- Frame an ML problem by defining the user decision, target, unit of observation, constraints and a measurable non-ML baseline.
- Build reproducible train, validation and test splits; stratify or group where needed and prevent temporal or entity leakage.
- Profile features and labels, handle missing values and encode numeric, categorical and text inputs inside pipelines.
- Train and interpret linear regression; inspect residuals and compare MAE, RMSE and business-weighted error.
- Train logistic regression; interpret probabilities, thresholds, precision, recall, F1, ROC-AUC and PR-AUC.
- Use decision trees and random forests; explain splits, overfitting, feature importance limits and class weighting.
- Use gradient-boosted trees with disciplined hyperparameter search and an untouched final test set.
- Apply k-nearest neighbours and support-vector machines after scaling; explain when their assumptions become costly.
- Cluster unlabelled data with k-means and evaluate usefulness beyond a visually pleasing plot.
- Reduce dimensions with PCA for exploration while separating visualisation from predictive evidence.
- Design cross-validation that respects time, users, groups and repeated measurements.
- Tune models without test-set leakage and record experiments, seeds, data versions and configuration.
- Handle class imbalance with thresholds, weights and resampling while measuring minority-class failures.
- Explain predictions with permutation importance and SHAP, including correlation and causality caveats.
- Audit subgroup performance, proxy variables, fairness risks and human consequences with a model card.
- Package the selected preprocessing and model pipeline behind a versioned prediction contract with regression tests.
AIEF-105
Deep Learning & Neural Networks (PyTorch)
Tensors and autograd, training loops, MLPs, CNN basics with transfer learning, attention and the transformer architecture (enough to understand what an LLM is), fine-tuning a small pretrained model with Hugging Face, regularisation, debugging training, GPU use on free notebooks, and reproducibility.
Named topics and tools
- • PyTorch fundamentals
- • One vision task
- • One text task
Feeds the project: Builds the deep model for Semester Project 2 and the honest comparison against the baseline.
Detailed ordered topics (16)
- Represent scalars, vectors, matrices and batches as PyTorch tensors; reason about shape, dtype, device and broadcasting.
- Build a computation graph and derive the intuition of gradients, chain rule and automatic differentiation.
- Implement a dense neural network with linear layers, activations, forward pass and a task-appropriate loss.
- Write a complete training loop with batches, optimiser steps, validation, checkpoints and deterministic seeds.
- Diagnose underfitting, overfitting, exploding or vanishing gradients and unstable learning curves.
- Compare SGD, momentum and Adam; tune learning rate, schedules, batch size, weight decay and early stopping.
- Use dropout, normalisation and data augmentation while measuring whether each regulariser helps.
- Build convolutional networks and explain filters, receptive fields, pooling and image tensor conventions.
- Fine-tune a pretrained vision model with frozen and unfrozen stages and a reproducible augmentation pipeline.
- Represent text with tokens and embeddings; batch padded sequences and mask invalid positions.
- Compare recurrent sequence models with attention and identify the limitations that motivated transformers.
- Implement scaled dot-product attention and trace query, key, value and attention-mask shapes.
- Fine-tune a small pretrained text model and compare it fairly against the classical AIEF-104 baseline.
- Use mixed precision, gradient accumulation and checkpoint recovery within limited GPU memory.
- Profile inference latency, throughput, memory and model size; introduce pruning, distillation and quantisation trade-offs.
- Publish a model card covering data, intended use, evaluation, limitations, safety and reproducible inference.
AIEF-106
Data Engineering, Vector Databases & Applied AI
ETL and ELT with idempotent pipelines, data-quality checks, orchestration and Parquet; text extraction, embeddings, pgvector, HNSW and retrieval evaluation; plus applied computer-vision, NLP, time-series and recommendation baselines so students understand the major professional AI problem families before specialising.
Named topics and tools
- • Reliable batch data pipelines and orchestration
- • Embeddings, vector search and retrieval measurement
- • Computer vision and NLP baselines
- • Time-series and recommendation baselines
- • One measured applied-AI specialization experiment
Feeds the project: Builds the ingestion pipeline and embedding store for Semester Project 2.
Detailed ordered topics (16)
- Design an idempotent ingestion pipeline with explicit inputs, outputs, run identifiers and replay-safe writes.
- Validate schemas, nulls, ranges, uniqueness and referential integrity; quarantine bad records instead of hiding them.
- Compare CSV, JSON and Parquet; partition analytical data and measure storage and scan trade-offs.
- Separate ETL from ELT and choose batch, micro-batch or streaming based on freshness and operational cost.
- Orchestrate dependent jobs with retries, backoff, checkpoints, alerts and observable run metadata.
- Extract clean, structured text and metadata from HTML, PDF and OCR sources while preserving provenance.
- Create embeddings in batches, version the model and normalisation choices, and cache deterministic outputs.
- Store embeddings in pgvector; perform cosine, dot-product and Euclidean search with metadata filters.
- Explain approximate nearest-neighbour search and tune HNSW recall, latency, memory and index-build trade-offs.
- Build labelled retrieval queries and calculate recall@k, precision@k, MRR and failure categories.
- Build a computer-vision pipeline covering image loading, augmentation, class balance and transfer learning.
- Build a classical NLP pipeline covering normalisation, TF-IDF, classification and linguistic failure analysis.
- Build a time-series baseline with temporal splits, lag features, seasonality and leakage-safe forecasting metrics.
- Build a recommendation baseline using popularity and collaborative signals; evaluate ranking and cold-start behaviour.
- Choose one applied domain and improve its baseline through measured experiments rather than framework complexity.
- Serve the data and embedding pipeline with versioned artefacts, lineage, tests, documentation and a rerunnable command.
AIEF-SP2
Semester Project 2 — Semantic Search & Classification Engine
Ingest a real corpus, build a classical baseline and a deep model, compare them honestly, and serve both search and classification from one service. The deep model is not required to beat the baseline: marks reward a rigorous, honestly reported comparison, because on small data a forced win is usually a tuned test set.
Deliverables
- Ingested real, licensed corpus of at least 5,000 documents
- Classical baseline model
- Deep model with a baseline-versus-deep comparison table over multiple seeds
- Vector-search service exposing /search and /classify, deployed live
- Evaluation report: classification metrics, retrieval recall@k, error analysis
- Repo, demo and 15-minute defence
Proves: Trains, honestly evaluates and serves classical, deep and embedding-based models.
Prompts you can measure, retrieval you can defend, agents that fail safely — assembled into a domain assistant that becomes the capstone.
AIEF-107
Large Language Models & Prompt Engineering
How LLMs behave operationally (tokens, context, sampling, cost, latency), using hosted and open-weight models through APIs, prompt patterns, structured output and tool calling, prompt versioning, evaluation-set design, LLM-as-judge and its biases, human spot-checks, hallucination, guardrails and prompt injection, caching and cost tracking. Evaluation design is a graded skill here, not an afterthought.
Named topics and tools
- • Prompting as measured engineering
- • Evaluation harnesses
- • Guardrails
Feeds the project: Designs and evaluates the prompts and guardrails for Semester Project 3.
Detailed ordered topics (16)
- Trace the evolution from language modelling and word embeddings to encoder, decoder and encoder-decoder transformers.
- Tokenise text and explain vocabulary, subwords, special tokens, context windows and multilingual token-cost effects.
- Trace self-attention, positional information, feed-forward blocks, residual connections and normalisation.
- Distinguish pretraining, instruction tuning, preference optimisation, inference and retrieval augmentation.
- Call hosted and open-weight models through typed adapters with timeouts, retries and provider-independent contracts.
- Control decoding with temperature, top-p, stop conditions, seeds where supported and explicit output budgets.
- Design system, user and few-shot prompts with clear task, context, constraints and refusal behaviour.
- Produce schema-constrained structured outputs and validate, repair or reject malformed responses safely.
- Implement tool calling with typed arguments, deterministic application-side execution and explicit result handling.
- Create a versioned golden dataset containing normal, edge, adversarial and refusal examples.
- Score extraction, classification and generation tasks with task-specific deterministic and model-based metrics.
- Validate LLM-as-judge against blinded human labels and report agreement, position bias and model-family bias.
- Measure hallucination, groundedness, completeness, style and refusal errors with a documented taxonomy.
- Threat-model prompt injection, sensitive-data disclosure and insecure output handling; implement layered controls.
- Measure latency, token use, cache hit rate and cost; compare quality/cost trade-offs across prompts and models.
- Ship a regression-tested prompt release with version history, rollback criteria and an honest evaluation report.
AIEF-108
RAG & Knowledge Systems
Production retrieval built first without a framework and then with LangChain or LlamaIndex: ingestion, parsing, chunking, embeddings, BM25 and dense hybrid search, reranking, query rewriting, access-aware metadata, citations, conversational context, incremental indexing, tracing and RAG evaluation for retrieval, groundedness and answer quality.
Named topics and tools
- • Framework-free RAG
- • Hybrid retrieval
- • Reranking and citations
- • RAG evaluation
- • Tracing and measured ablations
Feeds the project: Builds the retrieval pipeline and agent workflow for Semester Project 3.
Detailed ordered topics (16)
- Convert user needs into answerable retrieval questions and define document, passage, answer and citation ground truth.
- Parse, clean and deduplicate documents while retaining source, page, section, timestamp and access metadata.
- Compare fixed, recursive, semantic and structure-aware chunking through controlled retrieval experiments.
- Select embedding models using language, domain, dimension, cost and measured retrieval quality.
- Implement framework-free dense retrieval with metadata filters and source-linked citations.
- Add lexical BM25 retrieval and combine sparse and dense ranks with a documented hybrid strategy.
- Rerank candidates with a cross-encoder or LLM and measure the marginal quality, latency and cost.
- Transform ambiguous queries through decomposition, rewriting or hypothetical documents without losing intent.
- Measure recall@k, MRR, context precision, context recall, answer faithfulness and answer relevance.
- Run ablations over chunking, embeddings, k, hybrid search and reranking; keep only components that earn their cost.
- Build grounded generation that quotes sources sparingly, returns verifiable citations and abstains when evidence is weak.
- Add conversation context without allowing stale memory to override current retrieved evidence.
- Rebuild the measured pipeline in LangChain or LlamaIndex while preserving the framework-free evaluation harness.
- Model deterministic and model-driven steps as a LangGraph state graph with checkpoints and bounded retries.
- Trace retrieval, prompts, tools, latency and failures end to end without recording prohibited sensitive content.
- Operate an incremental index with document updates, deletions, access control, versioning and regression tests.
AIEF-109
AI Agents, MCP & Model Adaptation
Build bounded tool-using agents and deterministic workflows with typed tools, durable state, memory, human approval, LangGraph, MCP, tracing and failure evaluation. Then learn when adaptation is justified: audit an instruction dataset, run LoRA/QLoRA on a small open model, compare with prompting and RAG, quantise, serve and benchmark quality, latency, memory and cost.
Named topics and tools
- • Bounded agents and workflows
- • LangGraph and MCP
- • Human approval and agent evaluation
- • LoRA/QLoRA
- • Quantisation and serving
Feeds the project: Fine-tunes a small model for the domain in Semester Project 3.
Detailed ordered topics (16)
- Choose among deterministic code, workflow, RAG, tool-using agent and fine-tuning using risk and evaluation criteria.
- Design tools with narrow schemas, least privilege, idempotency, timeouts and explicit error contracts.
- Implement a bounded single-agent loop with tool selection, observation, stop conditions and failure recovery.
- Represent durable agent state and distinguish conversational context, application state and long-term memory.
- Build human approval and escalation checkpoints for high-impact, ambiguous or irreversible actions.
- Expose and consume an MCP server with authenticated tools, resource boundaries and auditable calls.
- Model a multi-step workflow in LangGraph with branching, retries, resumability and deterministic checkpoints.
- Evaluate task success, tool selection, argument accuracy, step count, latency, cost and safety violations.
- Study multi-agent coordination, delegation and failure amplification; use it only when evaluation proves value.
- Curate an instruction dataset with provenance, consent or licence, deduplication, quality checks and a data card.
- Create leakage-safe train, validation and test splits and a base-model benchmark before training.
- Fine-tune a small open model with LoRA and QLoRA; track configuration, checkpoints and training curves.
- Compare fine-tuned, prompted and RAG-assisted baselines on held-out task and general-capability regression sets.
- Quantise and serve the model; benchmark quality, latency, throughput, memory and operating cost.
- Document when the fine-tune should not ship and select the simplest approach supported by evidence.
- Integrate the chosen agent or adapted model behind a secure API with tracing, budgets and rollback controls.
AIEF-SP3
Semester Project 3 — Domain AI Assistant
An AI assistant for one real domain you choose and your teacher approves in week 5. Source documents must be public, openly licensed or synthetic — never private client data or confidential documents. This product becomes your Semester 4 capstone, so it must be passed before Semester 4 begins.
Deliverables
- RAG over at least 100 real documents, plus an agent workflow
- Prompts, guardrails and an evaluation set of at least 100 questions with measured results
- A fine-tuned small model with a defined role, compared against base and prompted-base (it need not win — report honestly what it did and did not improve)
- Authenticated Next.js chat product with streaming, citations, feedback and failure states, deployed live with measured cost per query
- Evaluation report
- Repo, demo and live defence
Proves: Builds and evaluates a domain-specific LLM application end to end.
Take Semester 3's assistant to production on AWS, justify its architecture, security and economics, then add one evidence-led advanced specialization.
AIEF-110
MLOps & AI Deployment (AWS)
Docker and Compose; CI/CD with GitHub Actions including an evaluation-regression gate; AWS used for real (RDS or Aurora Postgres, S3, and a container service such as ECS/Fargate or App Runner); secrets; model and prompt versioning; structured logging, metrics and tracing; LLM observability (latency, tokens, cost, feedback); rollback; load testing; and basic security hygiene.
Named topics and tools
- • AWS only
- • Containers
- • CI/CD
- • Monitoring and rollback
Feeds the project: Containerises, deploys and monitors the Semester 3 product for Semester Project 4.
Detailed ordered topics (16)
- Containerise frontend, API, workers and data services with reproducible multi-stage builds and health checks.
- Use Compose for local parity while separating build-time settings, runtime configuration and secrets.
- Design CI checks for formatting, types, unit, integration, security and AI-evaluation regressions.
- Build immutable artefacts, promote them through staging and production, and record provenance and approvals.
- Deploy containers on AWS using VPC boundaries, ECS/Fargate or App Runner and least-privilege IAM.
- Operate RDS PostgreSQL/pgvector with backups, migrations, connection pooling and recovery testing.
- Use S3 for versioned artefacts and datasets with encryption, lifecycle rules and scoped access.
- Run asynchronous AI work with queues, workers, retries, dead-letter handling and idempotency keys.
- Version data, models, prompts, embeddings and evaluation sets so every release is reproducible.
- Collect structured logs, metrics and traces across browser, API, retrieval, model and worker boundaries.
- Monitor errors, latency percentiles, throughput, token usage, cost, retrieval quality and user feedback.
- Set service objectives and alerts that indicate user impact rather than dashboard noise.
- Load-test realistic traffic, find bottlenecks and tune caching, pooling, concurrency, batching and rate limits.
- Perform safe database, application and AI-component rollbacks with feature flags and migration constraints.
- Respond to an injected incident using triage, containment, recovery, communication and a blameless post-mortem.
- Estimate AWS cost, enforce budgets and explain when serverless, managed or self-hosted infrastructure is justified.
AIEF-111
AI System Design & Evaluation
Requirements and architecture trade-offs (RAG versus fine-tune versus agent, build versus buy, model choice); the latency/cost/quality triangle; capacity and scaling; caching, batching and queuing; safety and abuse (OWASP LLM Top 10, prompt injection, data leakage, excessive agency); privacy basics; offline and online evaluation and regression suites; incident response; and communicating a system's limits. Evaluation design is graded explicitly here as a system property.
Named topics and tools
- • Design reasoning
- • Quantified cost and capacity
- • Threat modelling
- • Regression suites
Feeds the project: Produces the design document, cost analysis and evaluation harness for Semester Project 4.
Detailed ordered topics (16)
- Turn an ambiguous business request into users, decisions, functional requirements and measurable success criteria.
- Define non-functional requirements for quality, latency, availability, privacy, security, cost and maintainability.
- Choose deterministic software, classical ML, deep learning, RAG, agent or fine-tune through explicit trade-offs.
- Draw context, container, component, data-flow and deployment diagrams that agree with the running system.
- Design versioned APIs, schemas, event contracts and idempotent boundaries for evolving clients.
- Estimate traffic, token volume, storage, bandwidth, concurrency and monthly cost with stated assumptions.
- Design caching, batching, queues, backpressure and rate limits around workload and correctness constraints.
- Plan availability, redundancy, graceful degradation, provider fallback, backup and disaster recovery.
- Threat-model identities, data, prompts, tools and supply chain using abuse cases and trust boundaries.
- Mitigate prompt injection, data exfiltration, insecure output handling, excessive agency and denial-of-wallet.
- Apply privacy-by-design through minimisation, retention, deletion, encryption and tenant isolation.
- Design offline golden sets, adversarial suites, regression thresholds and human-review sampling.
- Design online experiments and feedback loops without confusing engagement with correctness or safety.
- Create release, rollback, incident and model/provider change procedures with accountable owners.
- Write an architecture decision record comparing build versus buy and quality, latency, cost and lock-in.
- Defend the complete design under changing scale, budget and safety constraints in a live system-design review.
AIEF-112
Advanced AI Specialization
A guided survey of computer vision, advanced NLP and multimodal systems, speech, forecasting, recommenders and reinforcement learning followed by one chosen specialization. Students read primary work, reproduce a baseline, build a provenance-aware data pipeline, train or adapt an advanced model, stress-test it, optimise inference and integrate it into the production capstone with a model/data card.
Named topics and tools
- • Computer vision, NLP, speech, forecasting, recommendation, RL and multimodal survey
- • One advanced specialization
- • Paper reading and baseline reproduction
- • Domain evaluation, robustness and inference optimisation
- • Model and data cards
Feeds the project: Adds one advanced, evaluated capability to Semester Project 4 without weakening the shared production requirements.
Detailed ordered topics (16)
- Survey computer vision, NLP, speech, forecasting, recommendation, reinforcement learning and multimodal systems by problem type.
- Select one specialization using target roles, available data, compute, ethical risk and a measurable portfolio outcome.
- Read a primary paper and convert its claim, dataset, baseline, metric and limitations into an experiment plan.
- Reproduce a credible baseline before introducing a larger model or more complex architecture.
- Build the specialization-specific data pipeline with provenance, labelling rules, validation and leakage controls.
- Implement the first advanced architecture for the chosen track and verify shapes, losses and outputs on tiny data.
- Train or adapt the model with tracked experiments, checkpoints, compute budgets and failure notes.
- Evaluate against strong baselines with domain metrics, subgroup analysis and qualitative error categories.
- Stress-test distribution shift, noisy inputs, missing context, adversarial cases and out-of-scope requests.
- Optimise inference through batching, quantisation, compilation, caching or model selection as the track permits.
- Design a human-in-the-loop workflow for uncertain, sensitive or high-cost predictions.
- Integrate the specialised model into the Semester 4 product through a versioned API and observable pipeline.
- Measure end-to-end product value rather than isolated model accuracy, including latency and operating cost.
- Write a model and data card covering intended use, prohibited use, limitations, licence and safety.
- Package a reproducible experiment with code, configuration, data instructions and a technical report.
- Present the specialization to a mixed technical/product panel and defend why the evidence supports deployment.
AIEF-SP4
Semester Project 4 (Capstone) — Take It to Production
Semester 3's assistant made production-grade: containerised, deployed on AWS with CI/CD and monitoring, with a written system design, a cost and safety analysis, an automated evaluation suite and a portfolio case study. Defended live.
Deliverables
- The Semester 3 product containerised and deployed on AWS with CI/CD and monitoring, with at least a 14-day uptime and incident record
- System design, cost and capacity analysis, and an automated evaluation suite
- One advanced specialization integrated with a reproducible experiment, model/data card and measured value
- Live defence before a panel (lead teacher, second marker, and an external reviewer where available)
Proves: Ships and operates a monitored, evaluated AI service in production.
Work like a delivery team, harden the capstone with real review and incidents, then convert the evidence into Pakistan, international-remote and freelance applications.
AIEF-113
Production Engineering Residency
A supervised engineering residency rather than another tutorial: client-style requirements, user stories, estimates, vertical milestones, pull requests, code review, weekly releases, changing scope, pilot-user feedback, production defects, incident response and individual ownership rotations across frontend, backend, AI, data and operations.
Named topics and tools
- • Team delivery and client-style requirements
- • Pull requests and professional code review
- • Cross-stack feature ownership
- • Release, incident and change management
- • Pilot feedback and individual live defence
Feeds the project: Produces the reviewed release history, incident evidence and individually defended production improvement required by Semester Project 5.
Detailed ordered topics (16)
- Enter a team repository, run the system, map its architecture and write a precise first-week risk and question log.
- Convert a client brief into user stories, acceptance criteria, non-functional requirements and explicit exclusions.
- Estimate work, split vertical milestones and maintain a delivery plan that exposes dependencies and risk early.
- Work through short-lived branches, focused commits, pull requests, review checklists and protected release rules.
- Review code for correctness, tests, security, performance and maintainability while giving actionable feedback.
- Respond to review without defensiveness, document decisions and escalate disagreements with evidence.
- Implement a production feature across Next.js, FastAPI, PostgreSQL and the AI layer without breaking contracts.
- Add unit, integration, end-to-end and AI-evaluation coverage appropriate to the feature's risk.
- Diagnose a seeded production defect from logs and traces; reproduce, fix, verify and write the incident record.
- Handle a mid-sprint requirement change by clarifying value, negotiating scope and protecting system quality.
- Prepare and deliver an async written update covering progress, evidence, blockers, risks and next actions.
- Run a client demonstration that explains outcomes, trade-offs and limitations without hiding failures.
- Operate a weekly release with staging verification, migration checks, monitoring and rollback readiness.
- Measure real or pilot-user behaviour and turn feedback into a prioritised improvement rather than feature churn.
- Rotate repository ownership so every student proves frontend, backend, AI, data and operational competence.
- Complete an individual live change and defence inside the shared system to prove personal authorship.
AIEF-114
Global AI Career, Interviews & Remote Client Delivery
Map real Pakistan, foreign-remote, contract and freelance roles to evidence; communicate in professional written and spoken English; conduct discovery calls; write estimates and proposals; practise Python, SQL, ML, LLM and system-design interviews; handle behavioural and pair-programming rounds; and understand contracts, confidentiality, intellectual property, timezone and remote-work expectations.
Named topics and tools
- • Pakistan and international role mapping
- • Python, SQL, ML and AI system-design interviews
- • Professional English and client discovery
- • Remote work, proposals and contracts
- • Evidence-led application strategy
Feeds the project: Produces the target-role gap matrix, interview evidence and client-ready communication pack required by Semester Project 5.
Detailed ordered topics (16)
- Map Pakistan, regional, foreign-remote, contract and freelance roles to realistic entry routes and experience expectations.
- Extract recurring skills from real job descriptions and maintain a traceable personal gap matrix.
- Write a one-page evidence-first resume tailored separately for AI engineering and full-stack AI roles.
- Build a professional LinkedIn profile and concise introduction without inflated titles or unverifiable claims.
- Communicate requirements, estimates, blockers and technical trade-offs in clear written English.
- Practise discovery calls: ask clarifying questions, confirm scope, identify data/privacy risks and summarise decisions.
- Write targeted applications and cover notes that connect job requirements to specific project evidence.
- Prepare freelance proposals with milestones, assumptions, exclusions, acceptance criteria and payment boundaries.
- Practise Python problem solving, data structures, complexity, debugging and clean implementation under time limits.
- Practise SQL joins, windows, aggregation, schema reasoning, query debugging and performance basics.
- Answer statistics, ML, deep-learning, evaluation and experiment-design questions with assumptions and caveats.
- Design ML, RAG, agent and full-stack AI systems on a whiteboard with scale, cost and failure reasoning.
- Prepare behavioural stories about ownership, conflict, failure, ambiguity, learning and ethical decisions.
- Practise remote interviews, take-home planning, pair programming and concise narrated debugging.
- Understand contracts, intellectual property, confidentiality, timezone commitments and safe handling of client data.
- Run a measurable application campaign with weekly review of response, interview and conversion rates.
AIEF-115
Portfolio, Open Source & Job Campaign
Turn the full programme into verifiable public evidence: three polished deployed projects, a production capstone, architecture diagrams, demos, evaluation reports, an engineering case study, an accessible portfolio site, one scoped open-source contribution, Pakistan and international resume variants, repeated mock interviews and a tracked, targeted application campaign with a 90-day continuation plan.
Named topics and tools
- • Evidence-first GitHub and portfolio
- • Technical case studies and product demos
- • Open-source contribution
- • Resume variants and mock interviews
- • Tracked job, internship and freelance campaign
Feeds the project: Produces the public evidence pack, application tracker and live capstone defence assessed by Semester Project 5.
Detailed ordered topics (16)
- Audit every repository for reproducible setup, clear ownership, licences, secrets, tests and professional commit history.
- Select three portfolio projects that demonstrate complementary ML, LLM and full-stack production skills.
- Rewrite each README around problem, users, architecture, data, evaluation, deployment, evidence and limitations.
- Create accurate architecture and data-flow diagrams linked to the code and deployed environment.
- Publish short product demos that show normal flow, failure handling, metrics and the student's own explanation.
- Write a technical case study about a difficult decision, failed experiment or production incident.
- Build a fast, accessible portfolio site with project evidence, contact route and no unverifiable proficiency claims.
- Make a scoped open-source contribution and document issue selection, communication, review and revision.
- Create Pakistan and international resume variants with role-specific keywords used honestly and naturally.
- Complete repeated Python, SQL, ML and system-design mock interviews and track rubric-level improvement.
- Perform a live unfamiliar-code review and propose a safe, tested change before editing.
- Defend the capstone's architecture, evaluation, security, cost and operational history before a panel.
- Prepare references, transcripts, certificates and identity-safe application materials in an organised job-search pack.
- Send a first batch of targeted applications and record role, evidence used, stage, feedback and follow-up date.
- Iterate portfolio and interview answers from employer feedback without misrepresenting experience.
- Complete the graduation hiring review with a concrete 90-day plan for employment, internship, freelance or open source.
AIEF-SP5
Semester Project 5 - Professional AI Engineering Launch
An individually accountable professional launch built on the production capstone: ship a reviewed cross-stack improvement in a team release, respond to an incident, defend the system live, publish verifiable portfolio evidence, complete interview circuits and run a targeted Pakistan/international/freelance application campaign. Assessment is based on evidence and improvement, never on whether an employer makes an offer.
Deliverables
- Reviewed cross-stack production release with issue, pull request, tests, staging evidence, monitoring and individual live change
- Incident timeline, fix, verification, communication and blameless post-mortem
- Public portfolio with three deployed projects, production capstone, architecture diagrams, demos, metrics and limitations
- Target-role matrix, Pakistan and international resume variants, client discovery/proposal pack and recorded interview circuit
- Tracked first application campaign, employer-feedback log and realistic 90-day continuation plan
- Final panel defence covering code, AI evaluation, system design, security, cost, teamwork and professional judgement
Proves: Performs as an individually accountable full-stack AI engineer and presents verifiable evidence for Pakistan, remote and contract opportunities.
Internship placement support
After you complete all five semesters and graduate, you can apply for internship opportunities listed by ALCI and its partners. ALCI also offers its own internships to graduates — for example on the ALCI platform or in teaching assistance. Opportunities depend on availability: we do not guarantee an internship or a job. Current openings appear in your dashboard once you graduate, and placements open as partner opportunities become available.