androidengineers.Book a session LEARN WITH A CLEAR DIRECTION
A self-paced path from your first Python program to production AI applications. Learn programming, software and ML foundations, LLMs, RAG, evaluation, and deployment.
Start with what an AI engineer does, then learn Python from your first script through a tested application. Continue through software, web, mathematical, and machine-learning foundations before LLMs, retrieval, evaluation, security, and deployment. The complete Python foundation is embedded here; no external course is required. Each stage builds skills and evidence for the final knowledge-assistant project.
Self-paced. Start with the role introduction and follow the full foundation sequence. If you already know a topic, use its exercise and exit check to demonstrate the skill before moving ahead. There are no weekly deadlines.
YOUR PROGRESSION
Complete the labs and keep the evidence. Use each checkpoint to decide whether to move forward or revisit a skill.
Module 1
Explain the vocabulary, responsibilities, and learning journey.
Evidence: Role map, first-project description, and a personal starting-point assessment.
Go to this stage’s final module →Modules 2–15
Write, test, and organize a complete Python application.
Evidence: 42 Python lessons and exercises, ending in a document-processing CLI and an exit review.
Go to this stage’s final module →Modules 16–19
Understand systems, web requests, data, quantitative reasoning, and learning from examples.
Evidence: Environment exercises, request-flow diagram, metric calculations, and leakage-aware dataset split.
Go to this stage’s final module →Modules 20–27
Develop model-backed applications with retrieval, evaluation, and security.
Evidence: Validated API, document index, retrieval comparison, release scorecard, and access tests.
Go to this stage’s final module →Modules 28–31
Evaluate adaptation, multimodal data, performance, and deployment.
Evidence: Model decision record, document checks, load report, and rollback demonstration.
Go to this stage’s final module →Module 32
Demonstrate an end-to-end project and defend its design.
Evidence: Working project, reproducible checks, failure demonstration, and reviewed portfolio.
Go to this stage’s final module →THE CURRICULUM
89 lessons across 32 modules. Open a module to explore its lessons and practical work.
Understand the role, vocabulary, responsibilities, and learning sequence before starting technical work.
Ready to move on when: Explain the role and identify the first project and skills you will build.
Learn and practise what python is and how a program runs, editor, terminal, virtual environments, and packages, expressions, names, and basic data types.
Ready to move on when: You distinguish a string containing digits from a number and can predict the value of each expression before running it.
Learn and practise strings, formatting, and unicode text, comparisons, boolean logic, and branching, input conversion and defensive validation.
Ready to move on when: All invalid cases fail before downstream processing; boundary values succeed.
Learn and practise lists, tuples, indexing, and slicing, dictionaries, sets, and record lookup, mutability, aliasing, and safe copying.
Ready to move on when: Your explanation identifies which object is shared at every step, rather than describing all assignment as copying.
Learn and practise for loops, while loops, and termination, comprehensions, sorting, and grouping, iterators, generators, and streaming batches.
Ready to move on when: The last partial batch is retained, invalid sizes fail, and you can explain when the generator’s work actually runs.
Learn and practise functions, arguments, return values, and scope, modules, imports, and executable entry points, type hints, optional values, and data contracts.
Ready to move on when: The missing-value behavior is explicit and you do not claim that an annotation validates incoming JSON.
Learn and practise exceptions, traceback reading, and error boundaries, context managers and reliable cleanup, debugging, logging, and reproducible failures.
Ready to move on when: You can explain the cause, show the failing and passing test, and confirm no sensitive payload is written to logs.
Learn and practise paths, text files, and safe file operations, json, csv, and schema validation, dates, time zones, and configuration values.
Ready to move on when: You distinguish event timestamps from elapsed time and never rely on bool("false") to parse configuration.
Learn and practise classes, instances, and encapsulated behavior, dataclasses, equality, and value objects, composition, protocols, and dependency injection.
Ready to move on when: Business logic can be tested without network access, and each fake failure produces the intended application outcome.
Learn and practise functions as values, closures, and callbacks, decorators and preserving function behavior, complexity, profiling, and memory-aware processing.
Ready to move on when: The results match and the report explains expected growth without claiming a universal timing from one machine.
Learn and practise unit tests, boundary cases, and assertions, fakes, integration tests, and deterministic fixtures, project metadata, reproducible setup, and cli design.
Ready to move on when: A fresh environment can follow the README and run the tests and one sample command.
Learn and practise relational tables, sql queries, and parameters, joins, aggregates, and pagination, transactions, constraints, and indexes.
Ready to move on when: The failed transaction leaves no partial local state and duplicate operation IDs are handled explicitly.
Learn and practise http requests, responses, and api contracts, api handlers, validation, and separation of concerns, authentication, secrets, retries, and idempotency.
Ready to move on when: Replays are deterministic, conflicting reuse is rejected, and the limitations of the teaching example are explicit.
Learn and practise async functions, awaiting, and bounded concurrency, threads, processes, queues, and backpressure, tabular data, arrays, and numerical-library concepts.
Ready to move on when: Unknown measurements are not counted as zero, and you can explain the difference between a scalar, vector, and table.
Learn and practise design a document-processing cli from requirements, implement and test the document-processing pipeline, python portfolio review and foundation exit checklist.
Ready to move on when: You can run, test, explain, debug, and modify the application independently. The checklist values must reflect demonstrated evidence, not simply be set to true.
Build the background needed before model-powered applications. Work through each concept and its exercise.
Ready to move on when: Explain each concept and complete its exercise before starting the AI application modules.
Build the background needed before model-powered applications. Work through each concept and its exercise.
Ready to move on when: Explain each concept and complete its exercise before starting the AI application modules.
Build the background needed before model-powered applications. Work through each concept and its exercise.
Ready to move on when: Explain each concept and complete its exercise before starting the AI application modules.
Build the background needed before model-powered applications. Work through each concept and its exercise.
Ready to move on when: Explain each concept and complete its exercise before starting the AI application modules.
Separate an AI service into transport, domain logic, and dependency adapters. A request schema checks shape; domain rules check meaning. An integer quantity can pass schema validation while still violating a rule that quantities must be positive. Keep these checks independent of a model so a fake client can exercise them.
Ready to move on when: At most three fake calls run simultaneously.
A baseline answers whether a complex system earns its cost. For ticket routing, begin with a majority-class classifier or keyword rules, then compare a learned model. Accuracy alone can hide poor behavior when almost every ticket belongs to one category. Precision asks how many predicted positives were correct; recall asks how many real positives were found.
Ready to move on when: No group appears in both development and test data.
Tokenization converts text into model-specific units. A word can occupy multiple tokens, and different languages can have different token costs. Budget input, retrieved evidence, tool schemas, and output together. Character count is useful for an application limit but is not a reliable token count.
Ready to move on when: Budget checks reject requests that cannot fit mandatory instructions and the response reserve.
Treat a prompt as one versioned component of an application contract. Specify the task, available evidence, output fields, and behavior when the task cannot be completed. Examples help clarify categories, but they must represent the boundary cases rather than only easy successes.
Ready to move on when: Format errors cannot trigger downstream actions.
Retrieval quality begins before the search call. Parse documents into text with source IDs, section boundaries, version information, and access scope. Preserve headings that explain a paragraph and units that explain a table. A parser that merges two columns can create statements that were never present in the source.
Ready to move on when: Every chunk can be traced to a source location and version.
Lexical search is useful for exact product names, error codes, and identifiers. Dense retrieval can match related phrasing when words differ. Hybrid retrieval combines candidate sets, but their raw scores are not necessarily comparable. Rank fusion is one way to combine orderings without assuming identical score scales.
Ready to move on when: Report candidate recall separately from answer correctness.
A useful rubric describes observable behavior. “Good answer” is difficult to reproduce; “states the correct eligibility condition and cites the current policy” can be reviewed. Include examples of passing, borderline, and failing answers so reviewers interpret the rubric consistently.
Ready to move on when: A permission regression blocks release regardless of average quality.
Authentication establishes identity; authorization determines what that identity may do. Derive the tenant and actor from trusted server state, then scope database queries, retrieval, caches, and tool calls. A model-produced tenant ID is untrusted input.
Ready to move on when: No cross-tenant content appears in evidence, answers, or cached responses.
Different failure types call for different interventions. Missing current knowledge often calls for retrieval. An unclear instruction calls for a better task contract. Repeated style or task-format failures may justify supervised adaptation once simpler approaches have been evaluated.
Ready to move on when: The report can recommend no tuning when evidence does not justify it.
Multimodal applications need provenance at a finer level than “this file.” For an invoice, retain page number, region or bounding box where available, extracted text, and the transformation that produced it. OCR can confuse characters, merge columns, or lose currency symbols. A language model can then confidently explain corrupted input.
Ready to move on when: The inconsistent quantity example is rejected for review.
Optimize the whole request, not just tokens per second. Measure queue wait, retrieval, first output, decoding, and validation separately. Streaming can improve perceived responsiveness while leaving total completion time unchanged. Batch processing may improve throughput but increase waiting time for an individual request.
Ready to move on when: Cache keys prevent reuse across incompatible tenants or versions.
A reproducible release packages application code, dependencies, configuration schema, prompt version, and retrieval/index compatibility. Pin the environment so a new machine can run the same checks. Keep runtime secrets outside the image and fail startup clearly when required configuration is missing.
Ready to move on when: A clean setup can run one successful request from the README.
Build independently using an original project brief and acceptance checklist. This is a project specification, not a completed implementation.
Ready to move on when: Another engineer can reproduce the project and challenge its design using the submitted evidence.
PROVE YOUR SKILLS
Use the final review rubric to identify gaps. Lesson completion tracks study progress; readiness comes from independently demonstrating the work.
Open the portfolio review rubric →