Three tracks.
One engineering standard.
Each Promptly cohort is built around the same principles: open-source tooling, project assignments, written code review, and a documented output at the end. The three tracks differ in scope, depth, and duration.
Back to HomeHow the Cohort Model Works
All three programmes run on a cohort schedule — participants move through the curriculum together, with assignments due at the end of each week or sprint. This structure creates external accountability and ensures code review happens at consistent intervals rather than whenever a participant feels ready to submit.
Materials are primarily written guides. Participants can read at their own pace within a week's window, then submit their assignment for review. Instructors return written feedback within a defined period before the next cohort week opens.
The curriculum covers what practitioners actually encounter: environment setup, dependency management, model APIs, data preparation, evaluation, and engineering habits. It does not cover topics that are interesting in an academic context but rarely appear in project work.
Each programme ends with a portfolio output — a repository or capstone project that documents what the participant completed. This is their own work, held in their own version control account, not a certificate issued by the school.
Working with Open Models
A five-week cohort introduction for participants who can write basic Python and want to work with widely used open-source AI models. Covers environment setup, running open models locally and via APIs, basic data preparation, and two small project assignments with code review. Includes a small portfolio repository at the end.
What is covered:
- Development environment setup and tooling
- Running open models locally (CPU and small GPU environments)
- Using open-source model APIs and SDKs
- Basic data preparation for model input
- Two project assignments with written code review
Programme steps:
- 01Enrolment and environment preparation (pre-cohort)
- 02Weeks 1–2: Environment, models, and first API calls
- 03Week 3: Data preparation and model input structure
- 04Weeks 4–5: Project assignments, submission, and review
- 05Portfolio repository compiled and handed to participant
Engineering Practice for AI Projects
A fourteen-week cohort programme covering engineering habits for AI projects — version control, code review, working with model serving, evaluation, and reproducibility. Includes three project sprints, written project summaries, and a small final capstone. Participants are expected to have working Python skills before joining.
What is covered:
- Version control workflows for AI projects
- Code review practices and conventions
- Model serving and inference management
- Evaluation frameworks and reproducibility
- Three project sprints with written summaries and capstone
Programme steps:
- 01Pre-cohort: Prerequisites check and environment confirmation
- 02Weeks 1–4: Engineering foundations and version control patterns
- 03Weeks 5–8: Model serving, evaluation, and sprint 1
- 04Weeks 9–12: Reproducibility, documentation, and sprint 2
- 05Weeks 13–14: Sprint 3 and capstone submission with review
Full Developer Programme
A thirty-two week part-time programme covering the modern open-source AI development stack — model serving, transformer-based architectures, retrieval-augmented systems, evaluation, and small-team engineering practices. Includes four large project sprints, code review on each, and a final capstone project. The programme documents what students complete; it does not promise employment outcomes.
What is covered:
- Transformer-based model architectures
- Retrieval-augmented generation (RAG) systems
- Production model serving and scaling patterns
- Small-team engineering workflows and practices
- Four project sprints with full code review and a capstone
Programme steps:
- 01Pre-cohort: Skills assessment and tooling setup
- 02Weeks 1–8: Foundations, architectures, and sprint 1
- 03Weeks 9–16: RAG systems, evaluation, and sprint 2
- 04Weeks 17–24: Model serving, team practices, and sprint 3
- 05Weeks 25–32: Sprint 4 and final capstone with documentation
Programme Comparison
Not sure which track fits? Use this table to compare scope and decide based on your current Python background and available weekly hours.
| Feature | Open Models RM 500 |
Eng. Practice RM 1,720 |
Full Dev RM 4,420 |
|---|---|---|---|
| Duration | 5 weeks | 14 weeks | 32 weeks |
| Python prerequisite | Basic | Working | Working |
| Code review | |||
| Portfolio repository | |||
| Transformer architectures | |||
| RAG systems | |||
| Final capstone project | |||
| Best for | Developers new to AI models | Devs building engineering habits | Full-stack AI developer path |
Shared Standards Across All Tracks
Privacy-compliant data handling
Participant data handled under Malaysian PDPA. Assignment submissions are not shared or used for any purpose outside the cohort.
Reproducibility as a requirement
All project submissions must include environment files and run instructions. Reproducibility is assessed as part of every code review.
Written over video-first materials
Course guides are searchable documents. Participants can return to any section at any time during the cohort without scrubbing through recordings.
Defined workload before enrolment
Weekly hour estimates are published on the programme page. Participants know the commitment before they pay — not after they start.
Version control in every track
Git-based version control is used across all three programmes. Project work is submitted through repositories, not file uploads or portals.
No employment outcome claims
Promptly documents what participants complete. Outcomes after the programme are not within the school's control and are not promised.
Programme Fees
Open Models
per cohort enrolment
- 5-week cohort schedule
- Written course guides
- 2 project assignments
- Code review on submissions
- Portfolio repository
Engineering Practice
per cohort enrolment
- 14-week cohort schedule
- Written course guides
- 3 project sprints + capstone
- Code review on all sprints
- Written project summaries
Full Developer
per cohort enrolment
- 32-week cohort schedule
- Full stack AI development
- 4 large project sprints
- Code review on every sprint
- Final capstone with docs
All fees in Malaysian Ringgit (MYR). Instalment arrangements available for the 32-week programme — contact us for details.
Questions before enrolling?
Send an enquiry with the programme name and your current Python background. Someone from the team will respond within one working day.
Book Now