# API Developer Path – Track Overview
Independent preparation for OpenAI's five Build-with-AI API courses – scoping, the Responses API and model selection, evals, agentic systems, RAG, performance and production operations.
import { Card, CardGrid, Badge } from '@prosefly/astro-components';
Bank code OAI-API 7 domains · 60-item mocks Free Academy API pathway
**Build, evaluate and operate an AI application on the OpenAI API.** This is the largest and most technical track in this section. It is independent preparation built from publicly available OpenAI learning objectives and product documentation – not an official OpenAI course, and not an official practice exam. Read the [credential landscape](/openai/credentials/) page first if you have not: Academy badges and pathway certificates are **not certifications**.
## What this track prepares you for
This track mirrors **all five courses of the Academy API pathway** (the "Build with AI" category, OpenAI API product):
| Academy course | Published time | What it covers |
| --- | --- | --- |
| **Scope AI Solutions** | 30 min | Spotting AI opportunities and planning a solution |
| **Evaluate AI Applications** | 70 min | Evals, failure analysis, quality checks |
| **Design and Build Agentic Systems** | 110 min | Agent roles, tools, handoffs |
| **Build with Retrieval-Augmented Generation** | 100 min | Retrieval pipelines and answer quality |
| **Optimize AI Application Performance** | 30 min | Quality, speed, reliability and cost in production |
Passing all five course assessments at **≥ 80%** earns the Academy **API pathway certificate of completion**. That certificate is not a certification and does not guarantee eligibility for the broader OpenAI Certification initiative – it proves you completed the pathway. This track adds two full-length independent mock exams and seven in-depth domain pages that go well beyond the ~340 minutes of Academy video, because the assessments reward judgment you only build by doing the work.
## Blueprint
Our seven domains and their weights on the OAI-API mock exams (60 items, 90 minutes):
| # | Domain | Weight | Items (approx.) | Course page |
| --- | --- | --- | --- | --- |
| 1 | Scoping AI Solutions | 12% | ~7 | [Domain 1](/openai/api/domains/d1-scoping-ai-solutions/) |
| 2 | The Responses API and Model Selection | **18%** | ~11 | [Domain 2](/openai/api/domains/d2-responses-api-and-model-selection/) |
| 3 | Evaluating AI Applications | 16% | ~10 | [Domain 3](/openai/api/domains/d3-evaluating-ai-applications/) |
| 4 | Designing and Building Agentic Systems | **18%** | ~11 | [Domain 4](/openai/api/domains/d4-designing-agentic-systems/) |
| 5 | Retrieval-Augmented Generation | 16% | ~10 | [Domain 5](/openai/api/domains/d5-retrieval-augmented-generation/) |
| 6 | Performance, Latency and Cost | 12% | ~7 | [Domain 6](/openai/api/domains/d6-performance-latency-and-cost/) |
| 7 | Production Safety and Operations | 8% | ~5 | [Domain 7](/openai/api/domains/d7-production-safety-and-operations/) |
:::tip[Where the marks are]
The Responses API (18%), Agentic Systems (18%), Evals (16%) and RAG (16%) together are **68%** of the mock. The exam rewards developers who can pick the right runtime, ground answers in retrieved evidence, and prove quality with evals – far more than it rewards recall of endpoint names.
:::
:::note[Two independent mock exams]
This track ships **two** full-length, domain-weighted independent mock exams. [Mock Exam 1](/openai/api/practice-exam/) is your diagnostic – sit it untimed first to find your weak domains. [Mock Exam 2](/openai/api/practice-exam-2/) is deliberately harder (more multi-constraint stems and `FIRST` / `BEST` / `MOST cost-effective` / `TWO` qualifiers, more scenario framing) – use it timed as your go/no-go gate before enrolling in or sitting the real Academy assessments. Every item across both mocks and the domain pages is distinct.
:::
## The mindset this track rewards
The API assessments reward one posture repeatedly: **an AI application is a system you scope, measure and operate, not a prompt you ship.** Correct answers tend to:
- **Scope before building** – define the job, the success metric and the cost envelope before choosing a model.
- **Choose the lowest effort that works** – start on `gpt-5.6-terra` or `gpt-5.6-luna`, escalate reasoning effort or model only when an eval proves you need to.
- **Ground claims in retrieved evidence** with citations, rather than trusting model knowledge.
- **Measure with evals** – a representative dataset and a grader beat a subjective "it looks better".
- **Match the runtime to the problem** – Responses + tools for control, the Agents SDK for code-first orchestration, the Agents API for durable managed cloud agents.
- **Operate safely** – rate and spend limits, moderation, retries with backoff, RBAC and network controls before launch.
Wrong answers tend to: reach for `gpt-6-astra` at `max` effort by default, skip evals and ship on vibes, put the whole knowledge base in the prompt instead of retrieving, and treat production concerns (limits, retries, residency) as someone else's job.
## Suggested time allocation (28-hour plan)
| Domain | Weight | Hours |
| --- | --- | --- |
| The Responses API and Model Selection | 18% | 6 |
| Designing and Building Agentic Systems | 18% | 6 |
| Evaluating AI Applications | 16% | 4.5 |
| Retrieval-Augmented Generation | 16% | 4.5 |
| Scoping AI Solutions | 12% | 3 |
| Performance, Latency and Cost | 12% | 2.5 |
| Production Safety and Operations | 8% | 1.5 |
## Hands-on preparation checklist
Do these in a real OpenAI API workspace – reading about them teaches nothing.
- [ ] Make a first **Responses API** call to `gpt-5.6-terra`, then re-run it with `store: true` and continue the conversation using `previous_response_id`.
- [ ] Add a **function** (tool) to a request, handle the `function_call` output item, and return a `function_call_output` on the next turn.
- [ ] Request a **structured output** with a JSON Schema via `text.format` and confirm the response validates against it.
- [ ] Run the same task on `gpt-5.6-luna`, `gpt-5.6-terra` and `gpt-5.6-sol` and write down the quality, latency and cost difference.
- [ ] Build a small **eval**: a 20-row dataset, one grader, a baseline run, then change the prompt and confirm the grader catches a regression.
- [ ] Create a **vector store**, upload three documents, and answer a question with **file search**, then read the citations it returns.
- [ ] Turn on **prompt caching** by keeping a long stable prefix and measure the cached-input cost drop.
- [ ] Stand up a minimal agent two ways – the **Agents SDK** locally and an **Agents API** session (`OpenAI-Beta: agents=v1`) – and compare who owns the loop.
- [ ] Add a **spend limit** and a **rate limit** in the dashboard and trigger a `429` on purpose, then implement exponential backoff.
## Track pages
12%
18%
16%
18%
16%
12%
8%
60 timed items · diagnostic
60 harder items · readiness gate