Applied Restful APIs and Integrations
In 2026 an API is no longer consumed only by human-written client code: it is the surface through which tool-calling LLM agents obtain real-time knowledge and take action, so contract design, authorization scope, idempotency and observability now carry safety weight they did not previously carry. The course keeps its RESTful and integration core while adding function-calling and Model Context Protocol tool surfaces, prompt-injection and tool supply-chain risk, agent evaluation harnesses, and cost and latency budgets for agent-orchestrated workflows.
Current description → proposed description
From eCommerce to data mining, web systems are the primary information repository of 21st century information technology. This course focuses on: web technologies, information architecture, digital media, web design and development, vulnerabilities and social software.
This course equips students with the skills to design, consume, and integrate RESTful APIs in modern software systems, with an emphasis on scalable architecture and cross-platform interoperability. Students will build and connect applications through secure, standards-based APIs that enable real-time communication between distributed services, devices, and data platforms. Topics include REST principles, API design best practices, authentication and authorization, versioning, rate limiting, webhooks, error handling, and API documentation. Students will also explore integrations with cloud services, AI/ML platforms, payment gateways, and third-party data providers across domains such as eCommerce, IoT, and enterprise systems. By the end of the course, students will be able to develop and deploy robust API-driven solutions and orchestrate multi-service workflows in production environments. The course also treats the API surface as the place where autonomous AI agents act, covering tool and function-calling schemas, the Model Context Protocol, scoped credentials, and human-in-the-loop guardrails for agent-initiated operations.
What changes
- Replaces stale web-design/digital-media catalog text with the department's RESTful API and integration proposal
- APIs designed as agent tool surfaces (function-calling schemas, Model Context Protocol)
- Prompt-injection, confused-deputy and tool supply-chain risk as first-class security content
- Agent evaluation harnesses, end-to-end tracing, and cost/latency budgets for orchestrated workflows
- Human-in-the-loop approval thresholds and audit logging for agent-initiated actions
6 proposed outcomes, mapped to 8 program outcomes
Each outcome below is written to be observable and assessable, and each is mapped to the program learning outcomes for which it produces evidence.
Students will be able to design versioned RESTful and event-driven API contracts - resource models, idempotent operations, pagination, rate-limit policy and error semantics - expressed in machine-readable OpenAPI specifications that both human developers and tool-calling LLM agents can consume without ambiguity.
The contract the student designs is itself what makes an agent's task execution secure and flexible against live resources - idempotent operations bound the damage of a repeated call, rate-limit policy and error semantics govern how an agent recovers, and the machine-readable specification is how the agent reaches real-time knowledge without ambiguity - which is the design work PLO 2.2 names.
Students will be able to construct multi-source integrations that acquire, normalize, validate and persist data from third-party APIs, webhook streams and enterprise databases, handling authentication, pagination, backoff and retry, partial failure and schema drift.
The CLO's named evidence - acquiring, normalizing, validating and persisting data from multiple APIs and databases under real failure conditions - is the data acquisition pipeline PLO 2.1 describes, applied to live production sources rather than curated datasets.
Students will be able to construct a governed agent tool surface over an existing service, exposing scoped operations through function-calling schemas and the Model Context Protocol, and engineering the tool descriptions, argument schemas and system prompts that steer an agent's selection and invocation of those operations.
Building and scoping the tool surface an agent acts through is the integration half of designing a domain-specific agent with real-time knowledge access (PLO 2.2); writing the tool descriptions, argument schemas and system prompts that govern tool choice is prompt engineering for alignment and formatting in a practical application (PLO 4.2); and doing so against a deployed enterprise service is LLM use in an industrial setting through APIs (PLO 6.1).
Students will be able to evaluate the security posture of an agent-accessible API surface - least-privilege scopes and credential handling, prompt-injection and tool supply-chain risk, confused-deputy exposure, and irreversible or destructive operations - justifying guardrails, human-in-the-loop approval thresholds and audit logging proportionate to the harm a mistaken call can cause.
Justifying guardrails, approval thresholds and audit trails in proportion to potential harm is the accountability, privacy and harm-mitigation work of implementing AI systems with ethical and legal integrity - an outcome the workbook states twice in identical words, once under Christian Faith (PLO 1.1) and once under Integrated Disciplinary Knowledge (PLO 3.2) - while the least-privilege scoping and injection defenses are what make an agent's task execution secure (PLO 2.2).
Students will be able to evaluate the reliability, cost and latency of API-driven and agent-orchestrated workflows using end-to-end tracing, replayable integration tests and scenario-based agent evaluation harnesses, refining contracts, tool schemas, system prompts, caching, retry policy and model selection from the resulting diagnostics.
Running an evaluation harness over tool-calling traces and then revising prompts, tool schemas and model choice from the measured failure modes is assessment against appropriate metrics followed by iterative refinement (PLO 6.2), and the cost, latency and caching budgets it produces are the operational conditions of deploying LLMs in an industrial setting (PLO 6.1).
Students will be able to communicate an integration's capabilities, constraints, failure modes and cost profile to both technical and non-technical stakeholders through published API documentation, an operational runbook, and a design review defending the architecture's trade-offs.
Publishing documentation and a runbook and then defending the design to a mixed audience is direct evidence of communicating technical results, limits and responsibility clearly to technical and non-technical listeners (PLO 5.1).
Program outcomes this course reaches
Filled cells are program learning outcomes with at least one supporting course learning outcome in this course. Sparse coverage is expected — no single course carries all twelve.
The workbook maps this course too
The proposal workbook's assessment map already assigns program learning outcomes to this course. The outcomes above were written to cover it.
| Program outcome | Workbook level | In this draft |
|---|---|---|
| PLO 2.1 Data Acquisition for Real Problems | D | covered |
| PLO 2.2 Domain-Specific AI Agents | D | covered |
| PLO 4.2 Prompt Engineering for LLMs | I | covered |
| PLO 5.1 Communicating AI to Any Audience | I | covered |
| PLO 6.1 LLMs in Industrial Settings | D | covered |
I = Introduced · D = Developed · AE = Assessed at Exit