New opportunity

Technical Curriculum Developer - AI Agents - Remote

Veeva Systems · Raleigh, United States

About this role

Veeva Systems seeks a Technical Curriculum Developer to teach customers, partners, and employees how to use, configure, implement, and integrate its platform, including Agentic AI capabilities. The role combines hands-on AI agent development with technical training: the developer will build agents for demonstrations and labs while owning advanced, coding-intensive courses. Veeva seeks either an AI solutions engineer who has become a trainer or a technical curriculum developer with demonstrable AI-building experience.

Responsibilities

Design training and lab environments that teach learners to build, configure, and deploy custom AI agents. Create working demos, reference implementations, sample code, sandbox data, and exercises based on real implementation scenarios.
Turn agent-development challenges—including tool calling, context management, prompt design, error handling, guardrails, and orchestration—into sequenced learning experiences. Keep current with agent frameworks and tool-integration patterns.
Maintain advanced courses involving Java and REST APIs. Apply learning objectives, scaffolding, assessments, and adult-learning principles without sacrificing technical accuracy.
Work with Product Management and Engineering on emerging architecture, APIs, and features, building courseware alongside general release. Partner with Professional Services, Managed Services, and Customer Support to address learner pain points.

Requirements

Bachelor’s degree in Computer Science, Engineering, or Instructional Design, or equivalent practical experience; 3+ years creating technical training, curriculum, or enablement content for technical audiences.
Hands-on experience building, configuring, deploying, and troubleshooting AI agents. Understand tool/function calling, RAG, context and memory management, multi-agent orchestration, prompt engineering, and evaluation. Examples of relevant frameworks or SDKs include LangChain, LangGraph, and Anthropic’s Claude Agent SDK or Claude Code.
Ability to read Java architecture and classes for minor development or debugging; strong REST API foundations; experience with Git, Postman, or similar API tools. Experience designing hands-on labs and instructor-led courses and/or eLearning, plus strong writing, presentation, and facilitation skills. Must be comfortable defining curriculum while product capabilities are still being built and have experience with Veeva Vault or the ability to learn a complex enterprise SaaS platform quickly.

Preferred

Experience with Model Context Protocol or comparable integration standards; familiarity with LMS platforms and authoring or AI tools such as Articulate, Camtasia, Arcade, Vyond, Gemini, or Claude.

The Raleigh, NC role is listed as remote; Veeva’s Work Anywhere approach allows working from home or an office with predictable collaboration hours. Base pay is $100,000–$175,000, with actual pay dependent on qualifications, experience, and location; additional variable or stock compensation may apply. Benefits include medical, dental, vision, and basic life insurance, flexible PTO, paid holidays, retirement programs, and a charitable giving program.

For full details about this role, click “Apply on company site” to view the employer’s original posting.

Skills for this role

AI agentsTechnical curriculum developmentInstructional designHands-on lab designJavaREST APIsLangChainLangGraphClaude Agent SDKClaude CodeTool callingRetrieval-augmented generationContext managementMulti-agent orchestrationPrompt engineeringAI evaluationModel Context ProtocolGitPostmanVeeva VaultArticulateCamtasiaArcadeVyondGeminiClaudeTechnical writingPresentationWorkshop facilitation

Checking your profile…

Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.

Understand the role

What matters most

Build agents that learners can use
The role builds custom AI agents, working demos, and reference implementations from scratch to anchor labs and live demonstrations. Prepare to explain how an agent implementation becomes a reproducible exercise with sample code and sandbox data.
Teach real agent-development problems
Courses must turn tool calling, context management, prompt design, error handling, guardrails, and orchestration into sequenced learning. The posting specifically calls for firsthand troubleshooting of flaky tool calls, context overflow, hallucinated actions, and permission issues.
Own coding-intensive technical courses
The developer maintains advanced Java and REST API courses and labs that mirror implementation scenarios. Instructional objectives, scaffolding, and assessments must preserve technical accuracy for technical and semi-technical learners.
Develop curriculum alongside the product
The posting calls for working with Product Management and Engineering on architecture, APIs, and configuration options while features are still being built, then developing courseware alongside general release. It also emphasizes quickly understanding unfamiliar product areas.
Use implementation feedback to close learning gaps
The role partners with Professional Services, Managed Services, and Customer Support to identify learner pain points, and trains customers, partners, and employees to use, configure, implement, and integrate the platform.

Likely challenges to think through

Teaching against a moving product
Likely preparation hypothesis: building courseware before capabilities are complete creates a trade-off between release timing and instructional accuracy. Prepare an approach for marking assumptions, validating examples with Product and Engineering, and updating labs when APIs or configuration options change.
Making unreliable agent behavior teachable
Likely preparation hypothesis: a polished live demo can hide the failures learners need to diagnose, while an uncontrolled lab may derail instruction. Prepare to describe bounded exercises that expose tool-call, context, and permission failures with observable outcomes and recovery paths.
Ramping up without oversimplifying
Likely preparation hypothesis: the stated expectation to build demos quickly in an unfamiliar product area makes speed compete with architectural understanding. Prepare a method for tracing APIs and Java classes, checking platform configuration assumptions, and deciding what learners must understand before attempting an integration.

Practice your answers

Technical practice

How would you build a working agent demo for an unfamiliar product area?

What to coverSuggested preparation: Explain how you would learn the product architecture and APIs, choose a bounded use case, and build a reference implementation that learners can configure and deploy. Address how you would verify the demo works before turning it into an exercise.

How would you teach reliable tool and function calling?

What to coverSuggested preparation: Describe an exercise that makes tool inputs, outputs, permissions, and failure paths visible to learners. Explain how you would prevent or detect hallucinated actions and improperly scoped calls.

When would you use RAG, context, or agent memory?

What to coverSuggested preparation: Compare what each approach contributes to an agent and the trade-offs in relevance, context limits, and maintainability. Explain how learners could diagnose an answer that uses the wrong information.

How would you decide whether an agent needs multi-agent orchestration?

What to coverSuggested preparation: Contrast a single agent with a coordinated workflow and identify when added complexity is justified. Cover how you would make handoffs and failures understandable in a lab.

How would you evaluate a prompt and its guardrails for an agent demo?

What to coverSuggested preparation: Define observable tests for task completion, incorrect actions, and responses that should be constrained. Explain how test results would guide changes to the prompt, guardrails, or implementation rather than relying on one successful run.

How would you troubleshoot flaky tool calls in a learner's agent?

What to coverSuggested preparation: Walk through how you would distinguish tool failures, invalid inputs, permission issues, and agent decision errors. Explain the error handling and diagnostic evidence you would include so learners can investigate rather than merely retry.

How would you debug a Java and REST API exercise?

What to coverSuggested preparation: Describe how you would trace a request through API behavior and relevant Java classes to isolate a minor defect. Explain how an API tool such as Postman could help reproduce and verify the issue.

What makes an agent-building lab repeatable and realistic?

What to coverSuggested preparation: Cover sandbox data, sample code, setup instructions, expected results, and recovery from common mistakes. Explain the trade-off between a realistic implementation scenario and an exercise learners can complete and troubleshoot.

How would you structure an advanced course on agent implementation?

What to coverSuggested preparation: Start with measurable learning objectives, then sequence configuration, coding, and troubleshooting exercises with appropriate scaffolding. Describe an assessment that tests independent application without watering down technical accuracy.

How would you introduce an MCP-style tool integration in training?

What to coverSuggested preparation: Compare a standardized tool-integration approach with a direct integration at the level of capabilities, permissions, and troubleshooting. The posting treats MCP or comparable standards as a plus, so keep any protocol-specific example grounded in what you actually know.

Behavioural practice

Tell me about defining technical training while a capability was still changing.

What to coverSuggested preparation: Use a real situation, your actions to resolve uncertainty and manage revisions, and the result for learners or course readiness. The role calls for building courseware alongside general release; avoid implying that a particular Veeva release followed your example.

Describe a time you worked with product or engineering to understand a new architecture or API.

What to coverSuggested preparation: Give the situation, how you obtained and checked technical details, and what your collaboration produced. Clarify your own contribution and how you handled information that was incomplete or changed.

Tell me about using support or services feedback to improve technical training.

What to coverSuggested preparation: Identify the learner pain point, the actions you took to validate and address it, and the observed result. Distinguish a curriculum gap from a product or implementation issue.

Describe a live technical demo or workshop that did not go as planned.

What to coverSuggested preparation: State the audience and situation, how you diagnosed the problem and kept learning on track, and the result. Show how you adapted your explanation for technical or semi-technical learners without glossing over the failure.

Tell me about rapidly learning an unfamiliar enterprise SaaS platform to teach others.

What to coverSuggested preparation: Explain the situation, how you explored its configuration and APIs, and how you checked your understanding before teaching. End with the concrete training or demo outcome, using a real example rather than assuming prior Veeva Vault experience.

Sharpen your knowledge

Topics to prepare

Agent architecture and tool integration
The posting requires understanding tool/function calling and multi-agent orchestration; MCP or a comparable integration standard is a plus. Draw an agent flow showing when it calls a tool, passes control, and handles a failed response. Explain why each step belongs in a learner-facing demo.
RAG, prompts, and context management
The posting names retrieval-augmented generation, prompt engineering, and context/memory management. Compare two ways an agent could answer a question using retrieved material, then explain what context to retain or discard and how you would teach that choice.
Agent reliability and evaluation
The posting calls out evaluation, guardrails, flaky tool calls, context overflow, hallucinated actions, and permission/scoping issues. Create a small test matrix with an expected behavior, a failure signal, and a recovery or guardrail for each of three failure cases.
Instructional design for technical learners
The role applies learning objectives, scaffolding, assessments, and adult-learning principles to coding-intensive courses. Outline a three-stage lesson that moves from a working agent demo to a guided lab and then an independently assessed task; state what each stage proves.
Java, REST APIs, and enterprise platform architecture
The posting expects Java code comprehension, strong REST foundations, and the ability to learn how Veeva Vault is configured and implemented. Trace a sample request through an API endpoint and Java classes, noting configuration assumptions and questions you would resolve before writing training. A sample system is preparation, not a claim about Vault's architecture.

Skills to revise

Build a teachable agent demo
The role builds agents, reference implementations, and live demos. As a preparation exercise, build and configure a small agent with a tool call, then write setup steps, sample inputs, expected outputs, and a deployment checklist. LangChain, LangGraph, or the named Claude tooling are examples in the posting, not mandated choices.
Troubleshoot an agent in front of learners
The posting requires firsthand troubleshooting rather than scripted success paths. Deliberately introduce a flaky tool response and an out-of-scope action into a practice demo; diagnose each, make the failure visible, and explain the fix in terms a technical learner can repeat.
Work through Java and REST API exercises
Advanced courses involve Java and REST APIs, with Git and Postman or similar API tooling listed. Read a small Java call path, make a minor debugging change, exercise the associated API request and error response, and record the change in Git.
Produce a runnable hands-on lab
The role owns lab environments, sample code, sandbox data, and exercises reflecting implementation scenarios. Draft one lab with prerequisites, a learner task, starter data, verification steps, an assessment criterion, and a troubleshooting note; run it from the learner instructions to find gaps.
Facilitate a technical walkthrough
Strong presentation and workshop facilitation are stated requirements. Rehearse a short live walkthrough of the lab, pause for a learner decision, and explain the same design trade-off first to a developer and then to a technical admin.
Turn emerging product details into courseware
The posting says courseware is built alongside general release with Product and Engineering, while service and support teams help identify pain points. For practice, take a hypothetical changing API description, list open questions for those teams, and revise a lesson and lab without presenting assumptions as settled product behavior.

Your preparation checklist

Select evidence of technical teaching
Prepare examples of technical curriculum or enablement work for developers, implementation consultants, admins, or power users. Note your role, audience, learning outcomes, and how you assessed them; the posting asks for 3+ years of this work.
Prepare an AI agent project walkthrough
Choose a project you can discuss firsthand. Be ready to explain how the agent was built, configured, deployed, and evaluated, including its tools, prompts, retrieval, context handling, and orchestration where applicable.
Document a troubleshooting example
Prepare a concrete account of diagnosing an agent failure, such as a flaky tool call, context overflow, hallucinated action, or permission issue. Show the evidence you used, the fix, and how you would teach learners to recognize it.
Sketch a hands-on agent lab
As preparation for the advertised practical case exercise, draft a small hypothetical lab with a learning objective, sample code or sandbox data, sequenced tasks, a guardrail or error-handling challenge, and an assessment. Label it as a proposed exercise, not Veeva courseware.
Rehearse a Java and REST explanation
Prepare a brief example of reading Java classes to trace or debug a minor issue, alongside a REST API request and response you can explain using Git, Postman, or comparable tools. The role maintains coding-intensive courses.
Practice a rapid product-ramp exercise
Outline how you would learn an unfamiliar enterprise SaaS feature’s architecture, APIs, and configuration, then turn it into a working demo and lab. Identify what you would verify with Product and Engineering while capabilities are still being built; do not assume access to Veeva Vault.
Plan a short live teaching segment
Rehearse explaining one agent concept to both technical and semi-technical learners, then demonstrating a small step and checking understanding. The posting emphasizes clear writing, presentation, and workshop facilitation.
Bring targeted employer questions
Ask the hiring manager how Training Services prioritizes courses near general release, how Services and Support surface learner pain points, and what the practical case exercise is intended to evaluate. The posting lists a hiring-manager conversation, a case exercise, and a final senior-leader conversation.

Availability last checked: Nov 4, 2026. Status can change after a check; confirm on the employer’s website. Report an issue · Our checking policy

KEEP EXPLORING

Similar AI jobs

Related skills and specializations in United States. Matched to this role, not your profile.

Explore more jobs

Finding similar opportunities…