Tier 2: Practitioner
"I can build and deploy AI-powered features in production systems."
Prerequisites
Foundation understanding is expected before diving into Practitioner concepts. If you haven't worked through Foundation, start there. The concepts here build on that base.
What This Tier Means
Practitioner demonstrates that you can independently build AI-powered features and deploy them to production. You understand technical implementation details, can make architecture decisions for standard AI patterns, and can troubleshoot issues when things go wrong.
At this level, you're ready to take on AI work on client projects with appropriate guidance. You can turn AI concepts into working code.
Elements to Explore
These are the concepts to understand at the Practitioner tier. Focus on hands-on implementation, building real things, not just reading about them.
| Element | Concept | What to Build |
|---|---|---|
| Fc | Function Calling | Implement tool use and API integration with LLMs. Design function schemas, handle responses, manage errors. |
| Vx | Vector Databases | Set up and query vector databases. Understand indexing, similarity metrics, and performance tradeoffs. |
| Rg | RAG (Advanced) | Build complete RAG pipelines. Implement chunking strategies, retrieval optimization, and context management. |
| Mm | Multi-modal | Work with vision and audio models. Understand input processing, use cases, and limitations. |
| Ag | Agents | Implement basic agentic loops. Understand planning, tool selection, observation, and termination conditions. |
| Fw | Frameworks | Gain proficiency in at least one major AI framework. Understand abstractions, patterns, and when to use them. |
| Sm | Small Models | Know when and how to use smaller models. Understand cost/latency/quality tradeoffs. |
| Cw | Context Windows | Implement context management strategies. Handle sliding windows, compression, and chunking. Optimize context for cost/quality tradeoffs. |
Assessment Approach
Practitioner assessment is 1 formal technical demonstration and implementation walk-through with an Expert.
What the Walk-Through Covers
During this session, you'll:
- Demonstrate your deployed feature live, showing it working in production
- Walk through the implementation, explaining the architecture, code patterns, and key decisions
- Answer technical questions. Expect questions like "Why did you choose X over Y?", "What would break if Z happened?", and "How would you improve this system?"
- Review code quality. The Expert will assess code patterns, error handling, security considerations, and architecture decisions.
What "Passing" Means
You've demonstrated you can build and deploy real AI features. You understand implementation details well enough to troubleshoot issues and make architecture decisions.
What "Production" Means
"Production" doesn't require enterprise scale or client-facing deployments. It means:
Real users, real purpose. Someone other than you uses it for actual work, not just clicking through a demo. Internal teammates count. A tool you built that 3 people on your team use daily is production.
Reliability expectations. It needs to work consistently. If it breaks, someone notices and cares. You've thought about error handling, not just the happy path.
Maintained over time. You've iterated based on feedback. You've fixed bugs. The code isn't a one-and-done experiment you never touched again.
Examples that count:
- An internal Slack bot that answers team questions using RAG
- A document processing pipeline your team uses weekly
- A personal tool you've maintained for months that solves a real problem
- An internal dashboard with AI-powered summaries
Examples that don't count:
- A Jupyter notebook you ran once
- A tutorial you followed without modification
- A demo you built for a presentation but never used again
- Something that "works on my machine" but isn't deployed anywhere
Portfolio: Ship Something Real
Practitioner portfolio requires 1 deployed AI use case that is production-worthy. This means real code running in a real environment serving real users, not a weekend hack or a loosely connected experiment.
Internal tools and personal projects count, but the bar is production quality: reliable, maintainable, and solving a genuine problem.
What to Document
1. Architecture Decisions
- Which periodic table elements are in play?
- Why did you choose this approach over alternatives?
- What tradeoffs did you accept?
Example architecture diagram:
User Query → API Gateway → RAG Service → Vector DB
↓
LLM API
↓
Response + Sources
2. Technical Implementation
- How does the system work?
- What frameworks/tools did you use?
- Show the key code patterns.
3. Challenges and Solutions
- What went wrong?
- How did you debug issues?
- What would you do differently?
Example format:
Challenge: Retrieval returning irrelevant documents
Investigation: Tested different chunk sizes and overlap
Solution: Reduced chunk size from 1000 to 500 tokens
Result: Precision improved from 60% to 85%
4. Measurable Outcomes Track key metrics for your feature:
| Metric | Target | Actual |
|---|---|---|
| Response latency (p50) | < 2s | 1.4s |
| Quality/accuracy | > 80% | 85% |
| Cost per request | < $0.05 | $0.03 |
| User satisfaction | > 4.0/5 | 4.2/5 |
Example Projects
Good Practitioner projects might include:
- A RAG system against internal documentation with measured retrieval quality
- An agent that completes a multi-step workflow with observable reasoning
- A function-calling integration with external APIs and error handling
- A multi-modal feature processing images or audio
Skills to Develop
Advanced Prompting
Can you:
- Design effective system prompts for consistent behavior?
- Implement prompt chaining for multi-step tasks?
- Use structured outputs (JSON mode, schemas) reliably?
- Debug and optimize prompts for production use cases?
Function Calling
Can you:
- Design function schemas with clear descriptions?
- Handle function call responses and errors gracefully?
- Implement parallel and sequential function patterns?
- Debug when the model calls the wrong function?
Vector Databases
Can you:
- Set up a vector database (Pinecone, Chroma, etc.)?
- Design chunking strategies for different document types?
- Implement and measure retrieval quality?
- Optimize for your latency and cost requirements?
RAG Implementation
Can you:
- Build an end-to-end RAG pipeline?
- Implement reranking for better results?
- Handle documents that don't fit in context?
- Measure and improve retrieval quality?
Agents
Can you:
- Implement a think-act-observe loop?
- Design appropriate termination conditions?
- Handle agent failures gracefully?
- Observe and debug agent reasoning?
Multi-modal
Can you:
- Integrate vision models to process images in your application?
- Handle different input formats and preprocessing requirements?
- Debug issues with multi-modal inputs (sizing, encoding, tokens)?
- Implement appropriate modality for your use case?
Small Models
Can you:
- Select an appropriate model size for a given task?
- Implement model routing or fallback strategies?
- Measure and compare quality across model sizes?
- Optimize for cost and latency in your deployment?
Context Management
Can you:
- Implement sliding window or compression strategies?
- Optimize context usage for cost and quality?
- Handle documents that exceed context limits?
- Design effective chunking for your use case?
Frameworks
Can you:
- Build with LangChain, LlamaIndex, or equivalent?
- Understand what the abstractions do underneath?
- Know when to use framework vs. direct API?
- Debug issues within framework code?
Evaluation & Guardrails
Can you:
- Implement automated evaluation for your AI features?
- Build input/output guardrails for production safety?
- Create test suites for AI behavior validation?
- Measure and track quality metrics over time?
Common Questions
Q: What counts as "production"?
Internal tools count. The key is it's used by real people for real purposes, not just a demo that sits on your laptop. See the "What Production Means" section above for detailed criteria. The bar is: real users, reliability expectations, and maintained over time.
Q: What if I'm not on an AI project at work?
This is common and not a blocker. Options:
-
Find an internal problem to solve. Every team has inefficiencies. Build something that helps your team, such as document search, meeting summarization, or code review assistance. You don't need permission to build an internal tool that makes your life easier.
-
Propose an AI enhancement. Take an existing system and add AI capabilities. Most projects have opportunities for intelligent search, summarization, or automation.
-
Volunteer for AI work. Other teams may have AI initiatives that need help. Reach out.
The constraint isn't "my project doesn't allow AI." It's whether you're willing to find or create the opportunity. Practitioners find ways to build.
Q: Does it need to be a full application?
No. A well-built feature within a larger system counts. The key is that you own the AI components end-to-end: you made the architecture decisions, wrote the implementation, and dealt with production issues.
Q: Can I use a personal project?
Preferably something work-related, but a substantial personal project that demonstrates the skills can work. Discuss with whoever will assess you.
Q: What if my project fails?
Document the failure. What went wrong? What did you learn? A thoughtful analysis of a failed project can be more valuable than a lucky success.
Q: Do I need to know every framework?
No. Proficiency in one major framework is sufficient. Understanding how to evaluate and learn new ones matters more than knowing all of them.
Learning Paths
Start Here
- Ensure Foundation concepts are solid
- Pick a project idea that's meaningful to you
- Start building immediately and learn by doing
Build Your Feature
- Work through each element hands-on
- Document decisions and learnings as you go
- Get feedback from others early and often
Ship It
- Deploy to production (internal is fine)
- Measure real-world performance
- Iterate based on what you learn
Prepare for Assessment
- Complete your portfolio documentation
- Review your code for quality
- Practice explaining your architecture
What's Next?
You can build and ship AI features. You've wrestled with production problems, made architecture decisions, and seen what actually works. That's significant.
As you continue to grow, consider the Expert tier. Expert is about leading AI initiatives, architecting complex systems, and multiplying your impact through mentorship. It's not just about knowing more. It's about guiding others and shaping AI direction for your team and organization.