Technical Curriculum Developer - AI Agents - Remote

What matters most

• Build working agent demos and labs

  The role builds AI agents from scratch to power demonstrations, reference implementations, and hands-on training on Veeva’s platform. Prepare to explain how an agent you built was configured, deployed, and made usable as a learning exercise.

• Teach real agent implementation problems

  Training must turn tool calling, context management, prompt design, error handling, guardrails, and orchestration into sequenced lessons. Prepare concrete troubleshooting examples, including unreliable tool calls, context overflow, hallucinated actions, or permission issues.

• Own technically rigorous courses

  The role maintains coding-intensive courses involving Java and REST APIs, plus lab environments, sample code, and sandbox data. Prepare to show how technical accuracy, realistic implementation exercises, learning objectives, and assessments fit together.

• Develop content alongside the product

  Product Management and Engineering provide insight into architecture, APIs, and configurations while capabilities are being built; courseware is developed alongside general release. Prepare an example of turning incomplete technical information into content that can be updated as details settle.

• Address needs across learner groups

  Training serves customers, partners, and Veeva employees. The role also works with services and support teams to identify pain points and requires live-demo and workshop facilitation. Prepare to explain how learner feedback changes an exercise without diluting its technical content.

Likely challenges to think through

• Teaching a moving target

  A likely difficulty is making courseware useful before emerging capabilities are fully settled, without presenting provisional behavior as final. Prepare a method for validating examples with Product and Engineering, recording assumptions, and revising labs as APIs or configurations change.

• Making agent failures reproducible

  Agent behavior such as flaky tool calls or hallucinated actions may be hard to demonstrate consistently in a lab. Prepare to discuss how you would use observable outputs, controlled scenarios, and troubleshooting checkpoints while still exposing learners to realistic failure modes.

• Balancing depth with teachability

  The courses need Java and REST API rigor while serving technical and semi-technical learners. Prepare a sample progression that states prerequisites, scaffolds a working exercise, and assesses whether learners can diagnose or implement—not merely follow steps.

• Ramping up on unfamiliar platform areas

  The posting expects working agent demos and lab exercises within days of encountering an unfamiliar product area. A likely trade-off is speed versus understanding its architecture, APIs, and customer configuration patterns. Prepare to describe how you would scope an initial exercise, test its assumptions, and identify what needs further validation.

Topics to prepare

• Agent architecture and tool integration

  Posting: The role requires tool/function calling and agent orchestration; MCP or comparable integration standards are a strong plus. Suggested exercise: diagram an agent’s decision flow, tool permissions, failure paths, and a possible multi-agent handoff. Explain where an MCP-style integration could fit without treating it as required.

• RAG, context, and memory

  Posting: Practical understanding of RAG and context/memory management is required. Suggested exercise: compare retrieval, conversation context, and persistent memory in a sample agent design; explain how you would handle irrelevant retrieval and context overflow.

• Agent reliability and evaluation

  Posting: Learners must be taught to address flaky tool calls, hallucinated actions, permission or scoping issues, error handling, and guardrails. Suggested exercise: write a small failure-mode table with a test, expected behavior, and mitigation for each issue.

• Java architecture and REST API fundamentals

  Posting: Advanced courses require Java and REST API fluency, including reading classes for minor development or debugging. Suggested exercise: trace a request through sample Java classes and explain the API request, response, error, and likely debugging point.

• Instructional design for technical audiences

  Posting: Courseware must use learning objectives, scaffolding, assessment design, and adult-learning principles without losing technical accuracy. Suggested exercise: turn one agent troubleshooting scenario into a sequence of objective, demonstration, guided practice, and assessment for a technical learner.

• Enterprise SaaS configuration and implementation

  Posting: Experience with Veeva Vault, or the ability to ramp up quickly on complex enterprise SaaS platforms, is expected. Suggested exercise: using only legitimately available product information, outline questions you would ask about architecture, APIs, configuration, and customer implementation before drafting a lab; do not assume access to a Vault environment.

Skills to revise

• Build an agent demonstration

  Posting: The developer builds working agents, demos, and reference implementations for training. Suggested exercise: build a small agent with a callable tool, a defined task, and a repeatable demonstration; document its configuration and deployment steps. The posting names LangChain, LangGraph, and Claude Agent SDK/Claude Code as examples, not mandatory choices.

• Diagnose a broken agent run

  Posting: First-hand troubleshooting of unreliable tool calls, context overflow, hallucinated actions, and permission issues is required. Suggested exercise: deliberately introduce one failure into a demo, capture what happened, fix it, and write a learner-friendly explanation of the diagnosis.

• Create a Java and REST API lab

  Posting: The role maintains coding-intensive courses, sample code, sandbox data, and exercises; Git, Postman, or similar API tooling is expected. Suggested exercise: prepare a small Java/API exercise with setup instructions, a request to inspect or change, a debugging checkpoint, and an answer key.

• Package a hands-on learning experience

  Posting: The role designs labs, sandbox exercises, instructor-led courses or eLearning for customers, partners, and employees. Suggested exercise: create a short lab guide for configuring and testing an agent, including prerequisites, learner tasks, expected results, and an assessment that checks understanding rather than script-following.

• Facilitate a technical walkthrough

  Posting: Strong presentation, facilitation, writing, and communication for technical and semi-technical audiences are required. Suggested exercise: rehearse a brief live agent demo twice—once for developers and once for technical admins—then revise explanations and troubleshooting prompts for each audience.

• Gather evidence of relevant work

  Identify examples you can substantiate of technical training for technical audiences, hands-on labs, AI-agent development, and Java and REST API work. The posting specifies 3+ years of technical training experience; do not substitute a newly made sample for past experience.

• Prepare an AI-agent project walkthrough

  Choose an agent you have built, configured, and deployed. Prepare a short architecture diagram and demo or sanitized artifacts showing its tools, retrieval or context strategy, orchestration, evaluation, and deployment decisions.

• Document troubleshooting decisions

  Write up real examples of unreliable tool calls, context overflow, hallucinated actions, or permission and scoping problems you encountered. Show how you diagnosed each issue and what changed; distinguish firsthand examples from hypothetical ones.

• Draft a sequenced hands-on lab

  As a preparation exercise, create learning objectives, sample code and sandbox-data assumptions, learner tasks, and a short assessment for building an agent. Show how the lab teaches error handling and guardrails without sacrificing technical accuracy.

• Refresh Java and REST API fluency

  Prepare a small example in which you trace a Java class or debug a minor issue and exercise a REST endpoint with Git and Postman or comparable tools. Be ready to explain how you would turn the example into a coding-intensive course exercise.

• Practice ramping up on an unfamiliar platform

  Outline how you would identify architecture, APIs, configuration options, and implementation constraints before building a demo. Use a hypothetical enterprise SaaS scenario rather than assuming access to Veeva Vault internals.

• Rehearse a practical case and live explanation

  The posting lists a practical case exercise but does not specify its format. Practice explaining a time-boxed agent-and-lab design to both technical and semi-technical learners, including your assumptions, tradeoffs, and a brief live demonstration.

• Prepare questions for the interviewers

  Ask how Product and Engineering share emerging API details before general release, how Services and Support surface learner pain points, and what distinguishes effective training for customers, partners, and Veeva employees.