AI/ML Support Specialist

Role Purpose & Context

Role Summary

The AI/ML Support Specialist is here to make sure our AI and Machine Learning models are behaving themselves in production. Day-to-day, you'll be the one diving into logs, troubleshooting API calls, and figuring out why a model isn't giving the right answers. You're the bridge between our customers, our support team, and the clever folks who build these models. This role sits right at the heart of our operations, specifically within the Technical_roles department. You'll be taking those tricky support tickets that the first-line team can't quite crack, digging deep, and getting to the bottom of things. When you do this well, our AI services stay online, our customers get accurate predictions, and everyone trusts our technology. If you don't, well, that's when the phones start ringing off the hook, and our engineers get dragged out of bed at 3 AM. The real challenge here is that AI systems can be a bit of a black box sometimes; it's not always obvious why they're misbehaving. You'll need to be a bit of a detective. But the reward? Honestly, it's seeing a complex system hum along because you identified a subtle bug, or helping a frustrated user get back on track. It's about being the hero who brings clarity to chaos.

Reporting Structure

• Reports to: Senior AI/ML Support Specialist
• Direct reports: None, though you'll often help out junior team members informally.
• Matrix relationships: AI Operations Specialist, Machine Learning Support Engineer, Technical Support Engineer (AI/ML),

Key Stakeholders

Internal:

• ML Engineers (they build the models, you help fix them)
• Data Scientists (they train the models, you tell them when the data's gone wonky)
• Product Managers (they care about what the customer sees, you make sure it works)
• Platform Engineering (they manage the infrastructure, you tell them when it's breaking)

External:

• Key clients (when an issue impacts them directly, you might be involved in the update calls)
• Vendors (sometimes the problem is with a third-party tool, and you'll work with their support)

Organisational Impact

Scope: Your work directly impacts our service reliability and customer satisfaction. If our AI models aren't working, our customers aren't getting value, and that hits our reputation and, frankly, our bottom line. You keep the wheels turning, making sure our technical products deliver on their promise.

Performance Metrics

Quantitative Metrics

1. Metric: Mean Time to Resolution (MTTR)
2. Desc: The average time it takes you to resolve a support ticket from when it's assigned to you.
3. Target: Under 4 hours for P3 tickets, under 8 hours for P2 tickets.
4. Freq: Weekly, reviewed monthly.
5. Example: You pick up a P3 ticket about a slow API at 10 AM, diagnose it, and resolve it by 1 PM. That's a 3-hour MTTR for that ticket.
6. Metric: First Contact Resolution (FCR)
7. Desc: The percentage of tickets you resolve on the very first interaction, without needing to escalate or follow up multiple times.
8. Target: Above 70% for your assigned tickets.
9. Freq: Monthly.
10. Example: A user reports a specific model prediction error. You identify it as a known data input issue, guide them to fix it, and close the ticket in one go. That counts towards FCR.
11. Metric: Tickets Closed per Week
12. Desc: The total number of support tickets you successfully resolve and close each week.
13. Target: Roughly 25+ tickets per week, depending on complexity.
14. Freq: Weekly, reviewed monthly.
15. Example: You might close 20 quick P4 tickets and 5 more complex P2/P3 tickets in a given week, hitting your target.
16. Metric: Knowledge Base Contribution
17. Desc: The number of new articles or significant updates you contribute to our internal knowledge base and runbooks.
18. Target: At least 2 new or majorly updated articles per month.
19. Freq: Monthly.
20. Example: After solving a tricky, novel issue, you write a clear, step-by-step guide for how to fix it next time, complete with screenshots and commands.

Qualitative Metrics

1. Metric: Problem Diagnosis Accuracy
2. Desc: How accurately you diagnose the root cause of an issue, distinguishing between data problems, model bugs, or infrastructure failures.
3. Evidence: Your initial diagnosis often matches the eventual root cause found by engineering. You rarely escalate an issue with an incorrect or vague assessment. Feedback from ML Engineers confirms your troubleshooting notes are helpful and precise.
4. Metric: Stakeholder Communication Clarity
5. Desc: Your ability to explain complex technical issues clearly and concisely to both technical and non-technical people.
6. Evidence: Business stakeholders understand your updates without needing follow-up questions. ML Engineers find your incident summaries comprehensive. You use the right level of detail for your audience, avoiding jargon where necessary.
7. Metric: Proactive Issue Identification
8. Desc: Your knack for spotting potential problems before they become critical incidents, perhaps from monitoring dashboards or recurring minor issues.
9. Evidence: You flag unusual patterns in logs or monitoring before an alert triggers. You might notice a trend in minor tickets that suggests a deeper underlying problem and bring it to the team's attention. You're not just reacting, you're looking ahead.
10. Metric: Documentation Quality & Utility
11. Desc: The usefulness and clarity of the runbooks and knowledge base articles you create or update.
12. Evidence: Junior team members successfully use your documentation to resolve issues. Your runbooks are complete, unambiguous, and follow our established standards. Other team members refer to your articles regularly.

Primary Traits

• Trait: Systematic Problem-Solver
• Manifestation: You don't just guess. When an AI model goes sideways, you'll follow a clear, logical path: check the logs, verify inputs, test the API, rule out infrastructure. You're the one asking 'what changed?' or 'what's the simplest explanation?' before diving into complex theories. You'll document your steps, even the dead ends, because you know that information is gold for the next person.
• Benefit: Our AI systems are complex, and randomly trying fixes can actually make things worse. We need someone who can calmly dissect a problem, isolate the variables, and get to the real root cause. This prevents us from chasing ghosts and ensures we fix the actual issue, not just a symptom. It's the difference between a quick patch and a lasting solution.
• Trait: Calm Under Pressure
• Manifestation: When a P1 incident hits at 2 AM, and everyone's panicking in the Slack channel, you're the steady voice. You can read a runbook, execute commands, and communicate status updates clearly, even when your heart's racing a bit. You prioritise based on actual impact, not just who's shouting loudest. You're the person who can focus on the technical steps when the business is breathing down your neck.
• Benefit: When a critical AI service is down, every minute costs us money or damages our reputation. Panic leads to mistakes, missed steps, and longer outages. We need someone who can keep a cool head, follow the process, and be the anchor for the team during those stressful moments. It's about being reliable when reliability matters most.
• Trait: Intellectual Curiosity
• Manifestation: You're not satisfied with just fixing an issue and moving on. You want to understand *why* it happened. You'll spend an extra 15 minutes digging through architecture diagrams, asking ML engineers 'how does this bit work?', or tinkering in a sandbox environment to see if you can break it in a new way. You're always trying to connect the dots and learn more about the systems you support.
• Benefit: This isn't just about closing tickets; it's about making our systems more robust. Someone with genuine curiosity identifies patterns in failures, suggests improvements to monitoring or documentation, and ultimately becomes a true subject matter expert. This trait helps us move from reactive support to proactive prevention, which is a huge win for everyone.

Supporting Traits

• Trait: Empathetic
• Desc: You can genuinely understand a user's frustration, even when the problem turns out to be user error. You're good at validating their feelings while still guiding them to a solution.
• Trait: Articulate
• Desc: You can explain complex technical concepts without resorting to jargon when talking to non-technical folks. You know how to summarise a P1 incident for a Product Manager in plain English.
• Trait: Patient
• Desc: You're willing to walk someone through the same troubleshooting steps for the tenth time if that's what it takes. You don't get easily flustered when explaining things.
• Trait: Resilient
• Desc: You can bounce back quickly after a stressful incident or a tough conversation. You don't let a bad day or a difficult ticket derail your whole week.

Primary Motivators

1. Motivator: Solving Tough Puzzles
2. Daily: You get a buzz from diagnosing a really tricky, intermittent bug in a complex system. That feeling when you finally pinpoint the root cause after hours of digging? That's what keeps you going.
3. Motivator: Being the Hero Who Fixes Things
4. Daily: You enjoy being the person who brings clarity and resolution during an outage. You like the feeling of getting a critical service back online and seeing the 'all clear' messages in Slack.
5. Motivator: Continuous Learning in a Technical Field
6. Daily: You're always keen to learn about new AI/ML concepts, cloud services, or monitoring tools. You'll happily spend time outside of incidents understanding how our systems work under the hood.

Potential Demotivators

Honestly, this job isn't always glamorous. You'll spend a fair bit of time on repetitive tasks, dealing with vague bug reports, and sometimes feeling like you're the punching bag for problems caused elsewhere. If you need every day to be a new, exciting challenge, or if you can't handle being the bearer of bad news, you might struggle.

Common Frustrations

1. Vague bug reports: 'The AI is broken' with no user ID, timestamp, or context. Honestly, it's like finding a needle in a haystack.
2. The blame game: You're the first point of contact, so you often get blamed for model failures that are actually due to upstream data quality issues from a different team.
3. Documentation debt: Trying to troubleshoot a complex ML system with outdated or non-existent runbooks. You end up reverse-engineering things during a live incident, which is incredibly stressful.
4. Repetitive manual tasks: Spending hours on things like password resets or simple diagnostics that *could* be automated, but there's never quite enough time to build the tools.
5. On-call fatigue: The occasional 3 AM page for an 'urgent' alert that turns out to be a false alarm or a non-critical issue. It's draining.

What Role Doesn't Offer

1. A purely proactive, 'build-only' engineering role. You're definitely on the front lines, reacting to issues.
2. A role where you're constantly building brand-new AI models or designing novel algorithms. That's for the ML Engineers.
3. A 9-to-5, completely predictable schedule. Incidents don't care about your weekend plans, unfortunately.

ADHD Positives

1. The fast-paced nature of incident response can be really engaging, providing that burst of focus needed to solve urgent problems.
2. The variety of issues you'll encounter means less routine boredom; every ticket can be a new puzzle.
3. Hyperfocus can be a superpower when deep-diving into logs to find a subtle error amidst a mountain of data.

ADHD Challenges and Accommodations

1. Keeping track of multiple open tickets and their statuses can be tricky. We use Jira, which helps, and we can set up reminders and visual cues.
2. Documentation, while crucial, can feel like a chore. We can break down documentation tasks into smaller, more manageable chunks and pair you with someone for reviews.
3. Switching contexts between different incidents or tasks might be challenging. We try to minimise unnecessary interruptions during critical work.

Dyslexia Positives

1. Strong spatial reasoning skills often translate well to understanding complex system architectures and data flows, which is key for troubleshooting.
2. Excellent verbal communication can be a huge asset when explaining issues to non-technical stakeholders or during incident calls.
3. Problem-solving through hands-on experimentation rather than just reading long documents can be very effective in this role.

Dyslexia Challenges and Accommodations

1. Reading and parsing dense log files can be demanding. We use tools like Splunk and Datadog which offer visualisations and search capabilities to help, and we encourage using text-to-speech tools.
2. Writing clear, concise documentation is important. We use templates, provide grammar/spell-checking tools, and always have peer review for critical runbooks.
3. Following complex written procedures can be hard. We focus on clear, step-by-step runbooks with diagrams where possible, and encourage asking for verbal clarification.

Autism Positives

1. A strong preference for logical, systematic problem-solving aligns perfectly with diagnosing technical issues in a structured way.
2. Attention to detail is critical for spotting subtle anomalies in data or logs that others might miss.
3. The ability to focus deeply on a single problem until it's resolved is incredibly valuable during incident response.
4. Direct and clear communication, especially in technical contexts, is highly appreciated here. We value precision over ambiguity.

Autism Challenges and Accommodations

1. Unexpected changes or urgent P1 incidents can be disruptive. We try to give as much notice as possible and have clear incident management protocols to reduce ambiguity.
2. Navigating social dynamics during incident calls, especially with multiple stakeholders, can be taxing. We encourage using chat for updates and focus on factual, concise communication.
3. Sensory overload from a busy office environment. We offer noise-cancelling headphones and flexibility for quiet work areas or remote work when focus is needed.

Key Responsibilities

Experience Levels Responsibilities

1. Level: AI/ML Support Specialist (Mid-Level)
2. Responsibilities: Independently pick up and resolve complex support tickets related to our AI/ML models, often the ones that have stumped the first-line team. This means diving into the details and not just following a script.
3. Take ownership of the entire lifecycle of an incident, from initial diagnosis through to resolution and post-mortem documentation. You're the one making sure it gets fixed.
4. Perform detailed log analysis and correlation across multiple systems (e.g., application logs, cloud monitoring, model server logs) to pinpoint the exact cause of a model's misbehaviour.
5. Troubleshoot API endpoint issues for our AI services, understanding HTTP status codes, authentication failures, and payload structures. You'll use tools like Postman to test things out.
6. Diagnose and differentiate between various types of model failures, like data drift, prediction latency spikes, or concept drift, using our monitoring dashboards and your own detective work.
7. Create and update clear, actionable runbooks and knowledge base articles for recurring issues. This means turning your hard-won knowledge into something others can use.
8. Communicate technical issues and their impact clearly to both our ML Engineers and non-technical stakeholders, making sure everyone's on the same page without getting bogged down in jargon.
9. Start to informally guide and mentor junior support analysts, helping them with trickier tickets or showing them how to approach a new problem. You're becoming a go-to person.
10. Supervision: You'll have weekly check-ins with your Senior Support Specialist to discuss your workload and any blockers. For routine tasks, you're expected to work independently, but for novel or high-impact issues, you'll consult with your senior or the relevant engineering team.
11. Decision: You have full authority to make routine troubleshooting decisions within established guidelines and runbooks. You can decide on the best approach to diagnose a problem and implement known fixes. Any exceptions, major changes to production, or escalations to engineering for code changes will need your senior's or the ML team's approval. You can't, for example, restart a critical production service without explicit sign-off, unless it's a documented step in a P1 runbook.
12. Success: You're successfully resolving a high percentage of complex tickets on your own, your MTTR is consistently meeting targets, and your documentation contributions are genuinely helping the team. You're also starting to identify patterns in issues, not just fixing them one by one.

Decision-Making Authority

• Type: Troubleshooting Steps for a Known Issue
• Entry: Follows a detailed runbook, escalates if the runbook doesn't cover the specific scenario or if unsure.
• Mid: Independently executes runbook steps, adapts them slightly for minor variations, and can diagnose if the issue deviates from the runbook. Can choose between multiple documented approaches.
• Senior: Designs new runbooks for novel issues, can deviate from existing runbooks with sound technical judgment, and makes real-time decisions during complex incidents without explicit step-by-step guidance.
• Type: Escalation to Engineering Team
• Entry: Escalates any issue that can't be resolved with a runbook, providing all gathered information.
• Mid: Decides when an issue requires engineering intervention after thorough diagnosis, providing a clear summary of the problem, steps taken, and proposed root cause. Can determine *which* engineering team to escalate to.
• Senior: Decides on the urgency and appropriate engineering team for complex, ambiguous issues. Can challenge engineering's initial assessment or suggest alternative investigation paths. Acts as the primary liaison during major incidents.
• Type: Customer Communication During Incident
• Entry: Provides updates using pre-approved templates under supervision.
• Mid: Drafts clear, concise customer updates (internal and external) based on the incident's status and impact, ensuring accuracy and appropriate tone. Seeks review for critical external communications.
• Senior: Owns all internal and external communication during major incidents, providing real-time updates to senior leadership and directly to affected customers. Can tailor messaging for different audiences and manage expectations.
• Type: Prioritisation of Workload
• Entry: Works on tickets as assigned, following the queue's priority order.
• Mid: Prioritises own ticket queue based on impact, urgency, and SLA, making judgment calls on which P3 to tackle before a P2 if it's blocking more users. Can re-prioritise with manager's agreement.
• Senior: Manages and re-prioritises the team's entire ticket backlog during peak times, making strategic decisions about resource allocation. Can push back on low-impact 'urgent' requests from stakeholders.

Competency Requirements

Foundation Skills (Transferable)

These are the bedrock skills that let you function effectively in any technical support role, but especially one dealing with the complexities of AI and ML. They're about how you think, how you communicate, and how you adapt.

• Category: Communication & Collaboration
• Skills: Active Listening: Genuinely hearing and understanding the user's problem, not just waiting to speak.
• Clear Written Communication: Writing concise, unambiguous ticket updates, emails, and documentation.
• Verbal Explanations: Translating complex technical issues into understandable terms for any audience.
• Teamwork: Working effectively with ML Engineers, Data Scientists, and other support colleagues during incidents.
• Category: Problem-Solving & Critical Thinking
• Skills: Logical Deduction: Following a systematic process to diagnose issues, ruling out possibilities one by one.
• Root Cause Analysis (RCA): Not just fixing the symptom, but digging to find the underlying cause.
• Pattern Recognition: Identifying recurring issues or subtle anomalies in data or logs.
• Prioritisation: Quickly assessing the impact and urgency of multiple issues to decide what to tackle first.
• Category: Adaptability & Resilience
• Skills: Learning Agility: Quickly picking up new tools, technologies, and troubleshooting techniques.
• Stress Management: Maintaining composure and effectiveness during high-pressure incidents.
• Flexibility: Adjusting to changing priorities and unexpected urgent requests.
• Emotional Intelligence: Managing your own reactions and understanding others' perspectives, especially when they're frustrated.

Functional Skills (Role-Specific Technical)

These are the specific technical and domain-specific skills you'll need to hit the ground running. We're looking for someone who understands how these systems work and how to poke around when they don't.

Technical Competencies

• Skill: Incident Triage & Root Cause Analysis (RCA)
• Desc: You'll need to systematically diagnose issues by isolating variables, analysing logs, and figuring out if the problem is with the data, the model, or the infrastructure. You should be comfortable using frameworks like the '5 Whys' to get to the bottom of things.
• Level: Intermediate
• Skill: API Endpoint Troubleshooting
• Desc: A solid grasp of RESTful principles, HTTP status codes (knowing the difference between a 400 Bad Request and a 503 Service Unavailable), authentication methods (API Keys, OAuth), and JSON payload structures. You'll be using tools to test these.
• Level: Intermediate
• Skill: Log Analysis & Correlation
• Desc: The ability to parse and correlate logs from various sources – application, ingress controller, database, model server – to piece together the sequence of events that led to a failure. This is often where the real detective work happens.
• Level: Intermediate
• Skill: Model Performance Monitoring Concepts
• Desc: You won't be building the models, but you'll need to understand the signals of their failure. Recognising concepts like model drift, data drift, prediction latency spikes, and concept drift from monitoring dashboards is crucial.
• Level: Intermediate
• Skill: Technical Documentation & Runbook Creation
• Desc: You'll be writing clear, unambiguous, and actionable guides that let someone else (or future you) safely resolve a complex, known issue, even under pressure. This is about making knowledge stick.
• Level: Intermediate
• Skill: Stakeholder Communication (Technical & Non-Technical)
• Desc: Translating a technical failure (e.g., 'P99 latency on the inference service breached the 500ms SLO due to a noisy neighbour issue on the K8s node') into a business impact statement ('The recommendation engine was slow for 15% of users for 30 minutes, we've isolated the cause and are implementing resource quotas to prevent recurrence').
• Level: Intermediate

Digital Tools

• Tool: Jira Service Management / ServiceNow
• Level: Intermediate
• Usage: Creating, updating, routing, and closing support tickets; building basic reports on your ticket queue and performance.
• Tool: Datadog / Grafana
• Level: Intermediate
• Usage: Reading dashboards, identifying alerts, pulling basic metrics (e.g., API latency, error rates) for specific services, and maybe building a simple new dashboard.
• Tool: AWS (CloudWatch) / GCP (Cloud Monitoring) / Azure (Monitor)
• Level: Intermediate
• Usage: Navigating the console to find and view logs, checking the status of services, acknowledging alerts, and pulling basic diagnostic information.
• Tool: Python (with pandas, requests)
• Level: Intermediate
• Usage: Writing small scripts to automate repetitive tasks, parse large log files, or test API endpoints programmatically. You won't be building models, but you'll use it for diagnostics.
• Tool: Postman / cURL
• Level: Intermediate
• Usage: Using pre-configured collections to manually test API endpoints, validate responses, and even write automated test scripts for common API checks.
• Tool: Confluence / Notion
• Level: Intermediate
• Usage: Following runbooks, documenting ticket resolutions, creating and maintaining complex runbooks, decision trees, and contributing to the knowledge base.

Industry Knowledge

• Area: Fundamentals of Machine Learning
• Desc: Understanding what an ML model is, how it's trained, what inference means, and the basic lifecycle of a model. You don't need to be an expert, but knowing the basics helps when troubleshooting.
• Area: Cloud Computing Basics
• Desc: Familiarity with core cloud concepts like VMs, storage (S3, GCS), networking, and managed services, particularly in AWS, GCP, or Azure. You'll be navigating these environments daily.
• Area: Software Development Life Cycle (SDLC)
• Desc: Understanding how software is developed, tested, and deployed helps you communicate effectively with engineering teams and understand where issues might originate in the pipeline.

Regulatory Compliance Regulations

• Reg: GDPR (General Data Protection Regulation)
• Usage: Understanding the basics of personal data handling and privacy, especially when troubleshooting issues that involve customer data. Knowing when to escalate a potential data breach or privacy concern.
• Reg: Internal Security Policies
• Usage: Adhering to our internal security protocols for accessing production systems, handling sensitive data, and reporting security vulnerabilities. This is non-negotiable.

Essential Prerequisites

• At least 2 years of hands-on experience in a technical support, operations, or SRE role, ideally with some exposure to cloud environments.
• A solid understanding of command-line tools (Bash/Shell) and basic scripting (Python is a huge plus).
• Experience with at least one major cloud provider (AWS, GCP, or Azure) for monitoring and basic diagnostics.
• A proven track record of diagnosing and resolving complex technical issues, not just following a script.
• Demonstrable experience with incident management processes and procedures.

Career Pathway Context

These aren't just a checklist; they're the foundational skills that mean you won't be starting from scratch. We expect you to be able to jump into our systems and start contributing fairly quickly, even if you need to learn our specific tools. If you've got these under your belt, you're well-positioned to grow into this role and beyond.

Qualifications & Credentials

Emerging Foundation Skills

• Skill: Prompt Engineering & LLM Integration for Support
• Why: Honestly, competitors are already using tools like ChatGPT and Claude to draft incident reports, summarise complex logs, and even suggest troubleshooting steps in minutes. Analysts who master this will be significantly more productive, freeing up time for deeper, more complex work. It's not a 'nice to have' anymore; it's becoming essential.
• Concepts: [{'concept_name': 'Context Windows & Token Limits', 'description': 'Understanding how much information an LLM can process at once and how to manage it effectively for complex queries.'}, {'concept_name': 'Temperature Settings for Tasks', 'description': 'Knowing when to ask for creative, varied outputs versus precise, factual responses from an LLM.'}, {'concept_name': 'RAG (Retrieval Augmented Generation)', 'description': "Learning how to connect LLMs to our internal knowledge bases and private data so they can give accurate, context-specific answers without 'hallucinating'."}, {'concept_name': 'Output Validation & Hallucination Detection', 'description': "Developing a critical eye to verify LLM outputs and identify when they're making things up, which is crucial in a support context."}, {'concept_name': 'Prompt Chaining for Complex Analysis', 'description': 'Breaking down a big problem into smaller steps, feeding the output of one prompt into the next to achieve a comprehensive analysis.'}]
• Prepare: This week: Start using a public LLM (like ChatGPT or Claude) for drafting internal emails, summarising long documents, or generating code comments.
• This month: Experiment with using an LLM to help you parse complex log files or suggest troubleshooting steps for a known issue (always verify the output!).
• Month 2: Research RAG architectures and how they can be applied to our internal documentation. Think about how you'd integrate an LLM with our Confluence.
• Month 3: Build a small, personal automation using an LLM API to assist with a repetitive support task, like drafting initial incident summaries.
• QuickWin: Start using LLMs to draft your daily stand-up updates or summarise long email threads right now. It's low-risk and gives immediate time back.
• Skill: Understanding MLOps Tooling & Concepts
• Why: As our ML systems become more mature, the line between 'support' and 'MLOps' gets blurrier. Knowing how models are deployed, monitored, and re-trained in an automated fashion will be crucial for effective troubleshooting and suggesting improvements. You'll need to speak the language of the MLOps team.
• Concepts: [{'concept_name': 'CI/CD for ML (MLOps Pipelines)', 'description': 'Understanding how code changes, data changes, and model retraining trigger automated deployments.'}, {'concept_name': 'Feature Stores', 'description': 'Knowing what a feature store is and how it impacts data consistency between training and inference.'}, {'concept_name': 'Model Registries', 'description': 'Understanding how different versions of models are managed and deployed.'}, {'concept_name': 'Container Orchestration (e.g., Kubernetes)', 'description': 'A deeper understanding of how our ML services run in containers and are managed by Kubernetes, beyond just basic `kubectl` commands.'}, {'concept_name': 'Infrastructure as Code (IaC)', 'description': 'Familiarity with tools like Terraform or Ansible, which define our infrastructure, as problems can often stem from misconfigurations here.'}]
• Prepare: This week: Read up on the basics of MLOps – what it is and why it matters. There are tons of free resources online.
• This month: Shadow an MLOps engineer for a day, if possible, or schedule a coffee chat to understand their day-to-day challenges.
• Month 2: Pick one of our internal MLOps tools (e.g., our CI/CD pipeline for models) and spend some time understanding its configuration and logs.
• Month 3: Propose a small improvement to a runbook that incorporates an MLOps-specific diagnostic step.
• QuickWin: Start looking at the deployment logs for our ML services when troubleshooting. You'll begin to see the MLOps pipeline in action.

Advancing Technical Skills

• Skill: Advanced Scripting & Automation
• Why: You'll move beyond just writing small scripts to automate *your* tasks. The expectation will be that you can identify repetitive tasks across the team and build more robust, shareable automation tools. This means better error handling, more modular code, and perhaps even contributing to a shared library of support scripts.
• Concepts: [{'concept_name': 'Modular Script Design', 'description': 'Writing reusable functions and modules for common tasks.'}, {'concept_name': 'Error Handling & Logging', 'description': 'Building robust scripts that gracefully handle failures and provide useful logs.'}, {'concept_name': 'API Integration (Advanced)', 'description': 'Writing scripts that interact with multiple APIs (e.g., Jira, Datadog, cloud APIs) to automate complex workflows.'}, {'concept_name': 'Version Control (Git)', 'description': 'Using Git for all your scripts, collaborating with others, and managing changes effectively.'}]
• Prepare: This week: Review your existing scripts and identify areas where you could add better error handling or make them more modular.
• This month: Pick one repetitive task that the whole team does and try to build a more robust, shareable automation for it.
• Month 2: Start contributing your utility scripts to a shared Git repository, getting feedback from peers.
• Month 3: Look into using a Python framework like `click` or `argparse` to build more user-friendly command-line tools.
• QuickWin: Make sure every script you write has basic logging and error handling. It's a small change with a big impact.
• Skill: Deeper Cloud Platform Expertise
• Why: As our infrastructure becomes more complex, you'll need to move beyond just viewing logs and status. You'll need to understand how to troubleshoot networking issues, security group configurations, and resource constraints within our cloud environments. This means getting comfortable with CLI tools and understanding IAM roles.
• Concepts: [{'concept_name': 'IAM Roles & Permissions', 'description': 'Understanding how access is granted and restricted within the cloud, and how this impacts service behaviour.'}, {'concept_name': 'Virtual Private Clouds (VPCs) & Networking', 'description': 'Troubleshooting network connectivity issues between services or to external APIs within the cloud.'}, {'concept_name': 'Cloud Storage (S3, GCS, Blob Storage)', 'description': 'Understanding how data is stored and accessed, and troubleshooting permissions or availability issues.'}, {'concept_name': 'Managed Services Troubleshooting', 'description': 'Diagnosing issues with cloud-managed databases, message queues, or serverless functions.'}]
• Prepare: This week: Pick one cloud service you use daily and dive deeper into its documentation, focusing on common troubleshooting scenarios.
• This month: Complete an intermediate-level cloud certification (e.g., AWS Solutions Architect Associate or GCP Professional Cloud Engineer).
• Month 2: Spend time experimenting with cloud CLI tools to inspect resources, tail logs, and diagnose network issues directly.
• Month 3: Take ownership of documenting a complex cloud-related troubleshooting scenario for a specific ML service.
• QuickWin: Start using the cloud CLI for tasks you'd normally do in the console. It's faster and helps you learn the underlying commands.

Education Requirements

• Level: Minimum
• Req: A Bachelor's degree in Computer Science, Engineering, Information Technology, or a related technical field.
• Alts: We're pragmatic here. If you've got equivalent practical experience (typically 4+ years in a relevant technical role) and can show us you've got the chops, that's absolutely fine. We value what you can do, not just where you studied.
• Level: Preferred
• Req: A Master's degree in a relevant technical discipline.
• Alts: While not essential, a Master's can give you a slight edge, especially if it focused on AI, ML, or distributed systems. But honestly, real-world experience often trumps extra degrees in our book.

Experience Requirements

You'll need roughly 2-5 years of hands-on experience in a technical support, operations, or Site Reliability Engineering (SRE) role. Crucially, some of that experience should involve supporting complex, production-grade applications, and ideally, you've had some exposure to AI or Machine Learning systems. We're looking for someone who's seen a few fires and knows how to put them out, not just someone who's read the manual.

Preferred Certifications

• Cert: AWS Certified Cloud Practitioner or Azure Fundamentals
• Prod: Amazon Web Services / Microsoft Azure
• Usage: These show you understand the basics of cloud computing, which is where most of our AI infrastructure lives. It means you'll be able to navigate our cloud environments more quickly.
• Cert: ITIL Foundation
• Prod: AXELOS
• Usage: Demonstrates an understanding of IT service management best practices, which is helpful for incident, problem, and change management in a structured support environment.
• Cert: Certified Kubernetes Administrator (CKA) or Certified Kubernetes Application Developer (CKAD)
• Prod: Cloud Native Computing Foundation (CNCF)
• Usage: Many of our ML services run on Kubernetes. Having a deep understanding of Kubernetes will make you incredibly effective at troubleshooting containerised applications and infrastructure issues.

Recommended Activities

• Regularly contributing to open-source projects related to monitoring, automation, or MLOps. It's a great way to learn and show off your skills.
• Attending industry meetups, webinars, or conferences focused on AI/ML operations or technical support. Keep up with what's new!
• Subscribing to relevant technical blogs or newsletters (e.g., The Morning Paper, ML Eng Newsletter) to stay informed about emerging trends and best practices.
• Taking online courses on advanced Python scripting, cloud architecture, or specific MLOps tools. There's always more to learn.

Career Progression Pathways

Entry Paths to This Role

• Path: Associate AI/ML Support Analyst (L1)
• Time: 1-2 years
• Path: Experienced IT Helpdesk / Technical Support Specialist
• Time: 2-3 years (with relevant technical exposure)
• Path: Junior MLOps Engineer / Data Operations Analyst
• Time: 1-2 years

Career Progression From This Role

• Pathway: Senior AI/ML Support Specialist (L3)
• Time: 2-3 years from this role
• Pathway: Junior MLOps Engineer
• Time: 3-4 years from this role

Long Term Vision Potential Roles

• Title: Lead AI/ML Support Engineer (L4)
• Time: 5-8 years
• Title: MLOps Engineer / Site Reliability Engineer (SRE)
• Time: 6-10 years
• Title: AI/ML Support Manager (L5)
• Time: 8-12 years

How Zavmo Delivers This Role's Development

DISCOVER Phase: Skills Gap Analysis

Zavmo maps your current competencies against all requirements in this job description through conversational assessment. We evaluate your foundation skills (communication, strategic thinking), functional skills (CRM expertise, negotiation), and readiness for career progression.

Output: Personalised skills gap heat map showing strengths and priorities, estimated time to competency, neurodiversity accommodations.

DISCUSS Phase: Personalised Learning Pathway

Based on your DISCOVER results, Zavmo creates a personalised learning plan prioritised by impact: foundation skills first, then functional skills. We adapt to your learning style, pace, and neurodiversity needs (ADHD, dyslexia, autism).

Output: Week-by-week schedule, each module linked to specific job responsibilities, checkpoints and milestones.

DELIVER Phase: Conversational Learning

Learn through conversation, not boring modules. Zavmo uses 10 conversation types (Socratic dialogue, role-play, coaching, case studies) to build competence. Practice difficult QBR presentations, negotiate tough renewals, and handle churn conversations in a safe AI environment before facing real clients.

Example: "For 'Stakeholder Mapping', Zavmo will guide you through analysing a complex enterprise account, identifying key decision-makers, and building an engagement strategy."

DEMONSTRATE Phase: Competency Assessment

Zavmo automatically builds your evidence portfolio as you learn. Every conversation, practice scenario, and application example is captured and mapped to NOS performance criteria. When ready, your portfolio supports OFQUAL qualification claims and demonstrates competence to employers.

Output: Competency matrix, evidence portfolio (downloadable), qualification readiness, career progression score.