A good fit if you…
- build Python applications independently;
- integrate HTTP APIs and validate JSON;
- handle errors, tests, configuration, and Git;
- want evidence-grounded applications, not prompt tricks.
Software Signal Learning · Stage 4 · In pipeline
Generative AI Application Development
Build and evaluate a grounded knowledge assistant that answers from documents, cites evidence, and intentionally abstains when support is missing.
This is not prompt-only training, foundation-model training, unrestricted-agent design, deep enterprise RAG, or full production-system engineering.
Designed for: Python application builders comfortable with APIs, JSON, validation, testing, errors, and Git. Stage 3 is one path—not a forced prerequisite.
- Planned format
- Live online cohort
- Proposed teaching time
- 14 sessions × 90 minutes
- Expected level
- Independent software builder
- Applied outcome
- Grounded knowledge assistant
Starting point
Is this course right for you?
Probably not the right fit if you…
- are new to Python or application development;
- want foundation-model training or unrestricted agents;
- expect a no-code prompt course;
- need full production platform engineering now.
Two valid entry paths
- Stage 3 / data and ML path
- Experienced software-engineering direct entry
Check your current readiness
Can you independently build a Python application that calls an API, validates structured data, handles failures, includes basic tests, and uses Git?
What you will be able to do
- Treat a model as a probabilistic external dependency.
- Construct context and instructions with explicit boundaries.
- Validate structured outputs against deterministic contracts.
- Embed, prepare, index, and retrieve source documents.
- Build basic RAG with traceable citations.
- Design grounding, clarification, and abstention behaviour.
- Add allow-listed, validated tools and bounded workflows.
- Create evaluation datasets and regression checks.
- Mitigate prompt injection, data exposure, and tool misuse.
- Reason about reliability, latency, quality, and cost.
Capability depends on prior readiness, practice, and completed work; no career or product outcome is guaranteed.
Applied outcome
Build and evaluate a grounded knowledge assistant
Ask questions over selected documents, receive evidence-linked answers, and demonstrate an intentional refusal when evidence is missing.
- Ingest
- Prepare
- Index
- Retrieve
- Ground
- Cite
- Abstain
- Evaluate quality, latency, cost
Deliverables
- Bounded Python application and selected document corpus
- Structured response with source traceability
- Evaluation dataset and answer/citation review
- Security, failure, latency, and cost report
Boundary: a grounded, evaluated application—not enterprise-scale RAG, unrestricted autonomy, model training, or production-platform engineering.
How the course is planned to work
Learn live
Fourteen proposed 90-minute online sessions with explanation, demonstrations, and guided implementation.
Integrate and test
Python/API work, document preparation, retrieval experiments, evaluation cases, and capstone development between sessions.
Review trade-offs
Selected reviews and support are planned. Provider, API cost, tooling, office hours, and recording access remain under validation.
Current curriculum design · Four phases · Fourteen lectures
Detailed curriculum preview
All curriculum is public without registration. Teaching sequence and exercises may be refined before launch without changing the goal or boundary.
Phase 1 — Building controlled model-backed applications
Understand the boundary, call models safely, construct context, and constrain output.
Lecture 1 — How generative AI applications actually workUnderstand LLMs as probabilistic software components.
Foundations and anatomy
- generative versus predictive AI; tokens/context; training/inference; user input, instructions, context, model call, processing, action
Limits
- hallucination, non-determinism, knowledge boundaries, when GenAI is wrong
Lecture 2 — Calling language models from PythonBuild a minimal app and treat the call as an external dependency.
API workflow
- authentication/secrets, requests/responses, model selection, parameters
Software concerns
- timeouts, exceptions, retries, rate limits, safe logging, client separation
Lecture 3 — Instructions, prompts, and context constructionDesign structured context rather than clever wording.
Messages and prompts
- roles and hierarchy; task, constraints, examples, output expectations, negative instructions
Context quality
- relevance, recency, conflicts, window limits, lost information
Lecture 4 — Structured outputs and deterministic boundariesValidate and integrate responses safely.
Contracts
- JSON schema, required fields, enums, nullable values, versioning
Validation
- parsing, business rules, repair/retry/reject; deterministic controls at action boundaries
Phase 2 — Retrieval, grounding, and evidence
Represent meaning, prepare documents, retrieve material, and connect claims to evidence.
Lecture 5 — Embeddings and semantic similarityRepresent text for similarity search.
Intuition and use
- vectors, distance, cosine intuition, document/query embeddings, nearest neighbours, deduplication/clustering awareness
Limits
- domain mismatch, text length, similarity is not truth, privacy, cost
Lecture 6 — Retrieval fundamentals and document preparationPrepare sources for useful evidence retrieval.
Pipeline and chunking
- ingestion, extraction, normalisation, metadata, versioning; fixed/semantic boundaries, overlap, context, parent-child awareness
Index
- embedding store, filters, source IDs, refresh, deletion
Lecture 7 — Building a basic retrieval-augmented generation pipelineConnect retrieval and generation into grounded QA.
Flow and implementation
- question, retrieval, context assembly, generation, sources; vector index, top-k, prompt assembly, citation metadata
Failures
- no evidence, conflicting evidence, excess context, answers beyond sources
Lecture 8 — Grounding, citations, and answer abstentionSeparate supported answers from unsupported confidence.
Grounding and abstention
- evidence-only answers, quote/citation boundaries, traceability, insufficient-evidence responses, clarifying questions, fallback/human review
Verification
- citation correctness, claim-source checks, retrieval versus generation diagnosis
Phase 3 — Tools, workflows, evaluation, and security
Add bounded actions and state, test systematically, and protect capabilities.
Lecture 9 — Tool calling and bounded actionsKeep authority and validation outside the model.
Tools
- function schemas, arguments, results, loops; calculator/search/lookup
Safety
- allow-lists, validation, authorization, idempotency, confirmation; recommendation versus execution
Lecture 10 — Stateful workflows and simple agent patternsBuild explicit multi-step workflows with limits.
State and patterns
- conversation/task state, intermediate results, persistence; plan-act-observe, router, reviewer, human approval
Boundaries
- steps, budgets, timeouts, retries, kill switch, bounded autonomy
Lecture 11 — Evaluation datasets and systematic testingMeasure quality with repeatable cases.
Design and metrics
- representative, edge/adversarial questions; evidence/criteria; success, groundedness, citation accuracy, retrieval recall, format, latency, cost
Review
- human scoring, judge limits, regression tests, version comparison
Lecture 12 — Security, privacy, and prompt injectionControl untrusted input and capability misuse.
Threats and controls
- prompt/indirect injection, exfiltration, tool misuse, secrets; separation, least privilege, filtering, sandbox awareness, confirmation
Data responsibility
- confidential/personal data, retention, vendors, redaction, consent
Phase 4 — Reliability, trade-offs, and complete application
Make product trade-offs explicit and integrate a bounded application.
Lecture 13 — Reliability, cost, latency, and product trade-offsRemain useful under failure, variability, and constraints.
Reliability/economics
- timeouts, fallbacks, caching, retries, degradation; tokens, context, batching, tiers
Product
- latency budgets, quality tiers, human review, observability, service expectations
Lecture 14 — Capstone: build and evaluate a grounded knowledge assistantAnswer from a knowledge base, cite evidence, and refuse unsupported requests.
Flow and controls
- ingestion, chunking, index, retrieval, grounding, structured response, citations; validation, abstention, tool/workflow limits, logging, failures
Evaluation/outcome
- test dataset, retrieval, answer/citation review, cost/latency; evidence-linked answers and intentional refusal; bridge to reliable systems
Expected commitment and technical readiness
Proposed teaching
21 instructor-led hours, excluding assignments, project work, and office hours.
Independent work
Python/API integration, documents, retrieval, evaluation datasets, security analysis, and capstone. Exact effort will be published before launch.
Technical readiness
Laptop, internet, Python app development, APIs, tests, and Git. Provider, local/cloud tools, and any model/API charges will be disclosed before launch.
Instructor
Suyog Joshi
More than 20 years in software engineering, architecture, banking, payments, and enterprise delivery, emphasising decomposition, evidence, debugging, maintainability, risk, and operations.
The course treats models as external dependencies inside structured contracts, deterministic boundaries, evaluation evidence, least privilege, failure handling, and product trade-offs—not prompt demonstrations.
About SuyogWhat still needs to be confirmed before launch
The curriculum direction is available for review. Launch operations will be announced only after the following items have been validated.
- learner demand, entry profiles, and lecture pace
- model providers, portability, pricing, and learner cost
- retrieval stack, documents, licensing, and privacy
- review/support capacity and capstone feasibility
- recording, accessibility, tools, and certificate criteria
- schedule, fee/tax, payment, application, and selection process
Confirmed dates, fees, delivery conditions and application terms will be published before applications open.
Register interestFrequently asked questions
Do I need Stage 3 first?
No. Experienced software engineers may enter directly when they can build Python/API applications and meet the stated prerequisites.
Is this a prompt-engineering course?
No. Instructions are one component. The emphasis is integration, contracts, retrieval, evidence, evaluation, security, reliability, latency, and cost.
Does it cover RAG and agents?
It covers basic RAG and bounded tool/workflow patterns. It does not promise deep enterprise RAG or unrestricted agents.
Will answers cite evidence and abstain?
Yes. Grounding, citation checks, insufficient-evidence responses, clarification, and intentional abstention are central.
Are API costs included?
No provider or fee is confirmed. Any required service accounts and learner costs will be disclosed before launch.
Does registering interest reserve a seat?
No. It creates no application, waitlist, seat, payment, or admission preference.
Do I need machine-learning experience?
Not necessarily. Strong Python application and API skills are required. Classical ML experience is helpful but Stage 3 is not mandatory for experienced software engineers.
Which model provider will be used?
The provider has not been confirmed. The course aims to keep application principles portable rather than becoming one vendor’s tutorial.
How much tool calling is included?
Enough to design and validate bounded deterministic tools while keeping authorization and execution outside the model. It is not a broad framework survey.
Does it cover vector databases?
The course uses a lightweight retrieval/index approach. Product-specific vector-database depth is not the primary objective.
Will we train or fine-tune an LLM?
No foundation-model training is planned. The course focuses on application development around model APIs.
How are hallucinations evaluated?
Through representative tests, evidence expectations, groundedness, citation checks, abstention, human review, and separate retrieval/generation diagnosis.
What does answer abstention mean?
The application intentionally declines or asks for clarification when evidence is insufficient instead of inventing a confident answer.
How is prompt injection handled?
The curriculum covers direct and indirect injection, untrusted retrieved content, least privilege, content separation, tool controls, secret protection, and human confirmation.
What will the capstone assistant do?
It answers over selected documents, cites evidence, validates structured output, refuses unsupported requests, and is evaluated for quality, latency, cost, and failure behaviour.
How is this different from LLM and RAG Engineering?
This course provides the broad application foundation. A future specialisation may go deeper into ingestion, hybrid retrieval, reranking, permissions, benchmarking, freshness, and production operations.
What should I learn next?
Engineering Reliable AI Systems is the next core stage for production-shaped controls, observability, release, incidents, recovery, and ownership.
Your position in the journey
Stage 3
Practical Machine Learning FoundationsStage 4
Generative AI Application DevelopmentStage 5
Engineering Reliable AI Systems
Practical Machine Learning FoundationsStage 4
Generative AI Application DevelopmentStage 5
Engineering Reliable AI Systems
Stage 3 and experienced-software-engineering direct entry are both valid. This is guidance, not a mandatory purchase sequence.
View the complete learning journeyInterested in grounded, evaluated GenAI applications?
Record course-specific interest without applying, paying, joining a waitlist, or reserving a seat.
Register interest