AI Engineering Internship — 1 Month
This one-month track introduces practical AI application engineering. Learners work through requirements, architecture choices, implementation, testing, and documentation on a scoped project. Depth is foundational; advanced agent systems and production hardening are covered in longer tracks.
- Python
- AI APIs
- Git
- Evaluation checks
- Technical documentation
Compensation terms are to be announced. Applications will not open until compensation, supervision, and legal review are approved and disclosed. No internship fee is charged.
Legal review of internship terms is still required before this opportunity can accept applications.
Program facts
- Duration
- 1 month
- Level
- Foundational
- Weekly commitment
- Approximately 15–20 hours per week (subject to final program schedule)
- Delivery
- Online
- Availability
- Coming soon — interest registration available
- Compensation
- Compensation terms to be announced
- Mentor / supervisor
- Mentoring format is subject to program approval before open enrollment. Do not assume continuous 1:1 mentorship unless stated on an open program.
- Delivery owner
- Assigned before enrollment opens
- Certificate policy
- Completion recognition is issued only when published assessment requirements are met. Certificate policy is confirmed at program open.
Audience, prerequisites, and selection
Audience
- Students and recent graduates exploring AI application engineering
- Developers with basic programming experience who want structured AI project practice
Prerequisites
- Basic programming familiarity (preferably Python)
- Comfort using a code editor and the command line
- Ability to commit ~15–20 hours per week
Selection criteria
- Demonstrated programming familiarity matching prerequisites
- Clear motivation aligned with the project scope
- Capacity to meet the published weekly commitment
- Ability to explain prior technical work
Responsibilities
- Clarify problem definition and requirements for the assigned project
- Propose and document architecture and technical decisions
- Implement the primary application flow with validation and basic logging
- Test expected behavior, invalid inputs, and edge cases
- Document the MVP and demonstrate understanding of the implementation
Topics covered through the project
- Python fundamentals for AI applicationsfoundational
- Working with AI APIsfoundational
- Prompt design and structured outputsfoundational
- Basic retrieval patternsfoundational
- Evaluation tests and failure handlingfoundational
- Security basics for user datafoundational
- Project documentation and demofoundational
Learning outcomes
- Implement a scoped AI feature against an external API
- Write basic evaluation checks for answer quality and failure modes
- Document architecture decisions and known limitations
Project specification
Build a scoped, source-grounded AI application with evaluation checks and documented failure handling.
- Problem statement · Illustrative
- Users need answers grounded in a small approved document set, with clear handling when evidence is missing.
- Primary user workflow · Illustrative
- Submit a question → retrieve relevant sources → generate a grounded answer → show citations or a refusal when unsupported.
- Functional scope · Illustrative
- Question intake, basic retrieval over a fixed corpus, answer generation via an approved AI API, citation or refusal path, and a simple result view.
- Technical components · Illustrative
- Python application entrypoint, HTTP or CLI interface, AI API client, retrieval helper, validation, logging, and evaluation checks.
- Data requirements · Illustrative
- A small static corpus provided or assembled for the project. No claim of production data access or Vasiva client systems.
- Testing expectations · Illustrative
- Happy-path grounded answer, unsupported-question refusal or safe fallback, and at least one invalid-input or API-failure case.
- Known limitations · Illustrative
- Not a production RAG platform. Scale, multi-tenant security, and continuous evaluation pipelines are out of scope for the one-month track.
- What counts as completion · Illustrative
- Working primary workflow, documented architecture, evaluation checks for the cases above, and a demonstration explaining decisions and limits.
Examples
- Build an AI knowledge assistant with source-grounded answers, evaluation tests, and appropriate failure handling
Deliverables
- Working MVP meeting published acceptance criteria
- Architecture and design notes
- Tests covering happy path and at least one failure mode
- Final demonstration and walkthrough
Example or assigned project work—not a published student achievement or employment guarantee. Student work is not assumed for commercial use without appropriate agreements. Sections marked illustrative are representative examples, not a fixed commercial brief.
Evaluation criteria
How work is reviewed — clarity of decisions matters as much as a working MVP.
- Working project that meets published acceptance criteria
- Tests covering core happy path and at least one failure mode
- Written design notes explaining trade-offs
Evaluation focuses on observable engineering evidence. Exact rubrics are published per program when approved.
01
Main workflow correctness
Does the primary user journey work as specified?
02
Code comprehension
Can the participant explain what the code does and why?
03
Architecture explanation
Are component boundaries and trade-offs articulated clearly?
04
Input validation
Are invalid inputs rejected or handled safely?
05
Testing
Are expected behavior and at least one failure mode checked?
06
Edge-case handling
Does the work account for realistic non-happy-path conditions?
07
Documentation
Can another engineer set up, run, and understand the MVP?
08
Demonstration
Is the working result shown with an honest account of limitations?
Frequently asked questions
Ready to build something real?
Choose a pathway, review a program, and register interest when enrollment opens.