Internal Tools Developer

Role Purpose & Context

Role Summary

The Internal Tools Developer is here to build and maintain the applications and automations that make our internal teams more efficient. You'll take ownership of specific projects, from understanding what people actually need to getting a working tool into their hands. This role directly impacts how quickly and effectively our colleagues can do their jobs, which, frankly, makes a huge difference to the whole business. You'll work at the intersection of our core engineering team and various business departments, translating their manual headaches into slick, automated solutions. When you do this well, teams save hours every week, errors drop, and everyone's a bit happier. If it's not done well, people go back to clunky spreadsheets, manual copy-pasting, and general frustration, which slows us all down. The challenge is often figuring out the *real* problem behind a vague request and then shipping something quickly that actually helps. The reward? Seeing your colleagues genuinely excited about a tool you built that saves them loads of time.

Reporting Structure

• Reports to: Senior Internal Tools Developer or Lead Internal Tools Developer
• Direct reports:
• Matrix relationships: Mid-Level Software Engineer (Internal Systems), Applications Developer (Productivity Tools), Business Systems Engineer,

Key Stakeholders

Internal:

• Sales Operations
• Finance Operations
• Customer Support Teams
• Product & Engineering Teams (for data access and integration)
• People & Culture (for HR tooling)

External:

• Third-party API providers (e.g., Salesforce, Stripe, Slack)
• Cloud platform vendors (e.g., AWS, GCP)

Organisational Impact

Scope: This role directly improves operational efficiency across various departments. By automating manual processes and building user-friendly internal applications, you'll reduce human error, speed up workflows, and free up colleagues to focus on higher-value tasks. Essentially, you're the engine oil that keeps the internal machinery running smoothly, allowing the whole organisation to move faster and more reliably. Your work might not be customer-facing, but it underpins almost everything we do internally.

Performance Metrics

Quantitative Metrics

1. Metric: Tool Adoption Rate
2. Desc: Percentage of target users actively using a new tool or feature.
3. Target: 75%+ of target user group actively using a new tool within 30 days of launch.
4. Freq: Monthly, post-launch for new tools.
5. Example: You build a new Sales onboarding tool. If 80% of new Sales hires use it regularly within a month, that's a win. If only 30% do, we need to figure out why.
6. Metric: Manual Hours Automated
7. Desc: Estimated hours saved for business teams by replacing manual tasks with your tools.
8. Target: Save >50 hours of manual work per month for a specific business unit.
9. Freq: Quarterly, based on user feedback and process analysis.
10. Example: You automate a Finance report that used to take 10 hours a week for one person. That's 40 hours saved per month, which is a clear win.
11. Metric: Bug/Support Ticket Resolution Time
12. Desc: Average time it takes you to address and resolve issues reported for tools you own.
13. Target: Average time to close support/bug tickets for your tools is less than 2 business days.
14. Freq: Weekly, tracked in our internal ticketing system.
15. Example: A Sales Ops colleague reports a bug on Monday morning; you've got it fixed and deployed by Wednesday afternoon. That's good service.
16. Metric: Feature Delivery Velocity
17. Desc: How consistently you deliver planned features within sprint cycles.
18. Target: Consistently delivers 8-10 story points per sprint, with minimal carry-over.
19. Freq: Per sprint (usually bi-weekly).
20. Example: You commit to delivering a new reporting module and a small UI tweak in a sprint, and you get both done. That shows good planning and execution.

Qualitative Metrics

1. Metric: User Satisfaction & Feedback
2. Desc: How happy your users are with the tools you build and your responsiveness to their needs.
3. Evidence: Users proactively thank you for improvements; they come to you with new ideas rather than complaints; positive comments in post-project surveys; you're seen as someone who 'gets it' and helps them out.
4. Metric: Code Quality & Maintainability
5. Desc: The clarity, structure, and future-proof nature of the code you write.
6. Evidence: Your code reviews are usually quick and positive; other developers can easily understand and contribute to your codebase; minimal technical debt accrues in your projects; you're not constantly fixing things that broke after a month.
7. Metric: Proactive Problem Identification
8. Desc: Your ability to spot potential issues or areas for improvement before they become big problems.
9. Evidence: You suggest improvements to existing processes or tools without being asked; you flag potential data inconsistencies early; you anticipate user needs and build for them, rather than just reacting.
10. Metric: Documentation Quality
11. Desc: How well you document your tools, APIs, and processes for future reference.
12. Evidence: Colleagues can use your documentation to understand how a tool works or how to fix a common issue without needing to ask you directly; new joiners can get up to speed on your projects faster.

Primary Traits

• Trait: Pragmatic Problem-Solver
• Manifestation: You're the sort who'll reach for a simple script or a low-code platform like Retool if it solves the problem in two days, rather than spending two months building a custom microservice. You're comfortable shipping a 'v0.1' to get feedback quickly, even if it's not perfect. Your focus is always on the outcome for the user, not on using the latest, trendiest tech for its own sake.
• Benefit: Honestly, our internal teams need solutions *now*. A perfectly architected system that arrives six months late is useless. Your ability to deliver real value quickly, even if it's not the 'prettiest' solution, directly impacts how much time and frustration we save across the business. It means getting a tool that saves 100 hours a month into people's hands this week, not next quarter.
• Trait: High-Empathy Engineer
• Manifestation: You'll spend time actually sitting with Sales Ops or Finance, watching them do their jobs, and really trying to understand their pain points. You're great at asking 'why' repeatedly to dig into the root cause of a problem, not just taking requests at face value. In meetings, you listen more than you talk, making sure you've truly grasped what's needed.
• Benefit: Internal tools only get adopted if they genuinely solve a user's problem and are easy to use. If you don't deeply understand the agony of, say, copy-pasting data between five different browser tabs, you'll build a technically functional tool that no one actually wants to use. Empathy ensures you build tools that are loved, not just tolerated.

Supporting Traits

• Trait: Resourceful & Self-Directed
• Desc: You can take a vague request, like 'make this report easier to get,' and figure out who to talk to, what data sources are needed, and the technical steps to deliver it. You're good at 'API wrangling'—digging through sparse documentation and figuring out how systems actually connect, even if it's a bit of a puzzle.
• Trait: Patient
• Desc: You can handle it when requirements change mid-project or when non-technical users give feedback that's a bit hard to parse. You don't get easily frustrated by the iterative nature of building internal tools.
• Trait: Articulate
• Desc: You can explain complex technical ideas and trade-offs to non-technical colleagues in plain English. For example, you can clearly say, 'We can build this quickly, but it won't be real-time; is that okay for what you need?'
• Trait: Process-Minded
• Desc: You naturally see how systems and workflows fit together, and you enjoy bringing a bit of order to what might feel like chaos. You like mapping out steps and finding ways to make things flow better.

Primary Motivators

1. Motivator: Solving Real-World Problems for Colleagues
2. Daily: You get a kick out of seeing a colleague's face light up when a tool you built saves them an hour a day. You're driven by making people's jobs genuinely easier and more enjoyable.
3. Motivator: Autonomy and Ownership
4. Daily: You enjoy picking up a project, owning it from start to finish, and having the freedom to figure out the best way to get it done. You like being the go-to person for a specific tool or automation.
5. Motivator: Variety and Learning
6. Daily: You'll work on different types of problems for different teams, meaning you're always learning new business processes and dabbling in various tech stacks. It keeps things fresh and stops you from getting bored.

Potential Demotivators

If you need every piece of work to be glamorous or customer-facing, you'll probably struggle here. A lot of your work is behind the scenes, making things hum. If you expect crystal-clear requirements and a perfectly defined roadmap, you'll be disappointed; ambiguity is a frequent visitor. And if you hate being the first point of contact when something you built breaks, this isn't the role for you.

Common Frustrations

1. You'll often get vague requests like 'Can you just build something to make the finance close easier?' and then be expected to deliver a magical solution with minimal guidance.
2. You are the first point of contact when a tool breaks, a data refresh fails, or someone forgets their password. This constant context-switching can really mess up your development flow.
3. Your work is critical for business operations but is invisible to the outside world. It won't be featured on the company homepage, and it's harder to build a public portfolio of flashy projects.
4. Every department believes their request is the most urgent. You'll spend a fair bit of time justifying your roadmap and, frankly, saying 'no' to people you work with every single day.
5. You will inevitably spend a good chunk of your time — maybe 40% — cleaning, validating, and untangling messy data from source systems you don't control before you can even start building anything useful.
6. Your carefully planned sprint will, on occasion, be completely derailed by an 'emergency' request from leadership that needs to be done by the end of the day. It happens.

What Role Doesn't Offer

1. A perfectly predictable daily routine – expect interruptions and shifting priorities.
2. A focus on bleeding-edge, experimental technologies for their own sake – pragmatism trumps novelty.
3. A large, dedicated QA team – you'll be doing a lot of your own testing and validation.
4. A clear path to becoming a manager if you're solely focused on individual contribution – while possible, it's not the only or primary progression path.

ADHD Positives

1. The variety of projects and problem-solving keeps things interesting and can suit a mind that thrives on novelty and quick context switching.
2. The immediate, tangible impact of internal tools can provide quick feedback loops and a sense of accomplishment, which can be highly motivating.
3. Opportunities for rapid prototyping and 'shipping a v0.1' align well with a desire to see progress quickly rather than long, drawn-out projects.

ADHD Challenges and Accommodations

1. Frequent interruptions for support tickets or 'urgent' requests can make deep work difficult. We can explore using focus blocks or dedicated 'support days' to manage this.
2. Ambiguous requirements can be tough. We'll work on breaking down vague requests into smaller, clearer steps and use visual aids where possible.
3. Documentation, while essential, can feel tedious. We can use templates, AI-assisted tools, and pair-writing sessions to make it less of a chore.

Dyslexia Positives

1. Strong logical and problem-solving skills, often associated with dyslexia, are highly valued in breaking down complex system integrations.
2. The emphasis on visual tools (like low-code platforms and UI design) can be a strength, allowing you to express solutions effectively.
3. The ability to see the 'bigger picture' of how processes fit together can help in designing intuitive internal workflows.

Dyslexia Challenges and Accommodations

1. Extensive reading of technical documentation or complex codebases can be challenging. We encourage the use of screen readers, syntax highlighting, and AI tools for summarisation.
2. Writing detailed documentation might take longer. We can offer tools like Grammarly, templates, and peer review support.
3. Verbal communication is often preferred for initial requirements gathering, reducing reliance on written briefs.

Autism Positives

1. A strong focus on logic, systems, and detail is highly beneficial for debugging, API integration, and ensuring tools are robust.
2. The clear, tangible outcomes of internal tools development can be very satisfying, as you see direct results of your work.
3. The role often involves deep, focused work on specific technical problems, which can be a comfortable and productive environment.

Autism Challenges and Accommodations

1. Unexpected changes in priority or 'urgent' requests can be disruptive. We aim for clear communication about changes and provide as much notice as possible.
2. Navigating social dynamics in requirements gathering can be tricky. We can support with structured meeting agendas, pre-reads, and clear follow-up notes.
3. Sensory environment: we can offer noise-cancelling headphones and flexibility in workstation setup to reduce sensory overload.

Key Responsibilities

Experience Levels Responsibilities

1. Level: Mid-Level Internal Tools Developer (L2)
2. Responsibilities: Independently build, test, and deploy small to medium-sized internal applications or automation scripts from scratch. This means taking a problem, figuring out the solution, and shipping it.
3. Take ownership of existing internal tools, handling bug fixes, feature requests, and general maintenance. If it's yours, you're the first port of call.
4. Design simple database schemas and write efficient SQL queries for new tools, making sure the data is structured correctly for what you're building.
5. Integrate internal tools with third-party APIs (like Salesforce or Stripe) and other internal systems. This often means figuring out how to get two systems that weren't designed to talk to each other, well, talking.
6. Work closely with non-technical users to gather requirements, translating their 'I wish it could...' into clear, actionable technical specifications. You'll need to ask lots of questions.
7. Write clear, concise documentation for the tools you build, covering how they work, how to use them, and common troubleshooting steps. Future-you (and everyone else) will thank you.
8. Participate in code reviews for your peers, offering constructive feedback and learning from others' approaches. It's how we all get better.
9. Supervision: You'll typically have weekly check-ins with your manager or a Senior Developer to discuss progress, unblock any issues, and get feedback. For routine tasks, you'll work pretty independently, but for anything new or tricky, you'll know when to ask for help or guidance.
10. Decision: You'll make routine technical decisions within the scope of your assigned projects, like choosing a specific library or optimising a query. For anything impacting other systems, significant architectural changes, or anything over £5K in potential cost, you'll need to consult with a Senior Developer or your Lead. You're expected to identify issues and propose solutions, but major strategic shifts aren't on your plate just yet.
11. Success: You're successful when your tools are reliably deployed, actively used by their target audience, and genuinely solve the problem they were built for. You're also expected to deliver features consistently and maintain a high standard of code quality, meaning fewer bugs and easier maintenance down the line.

Decision-Making Authority

• Type: Technical Approach for a New Tool
• Entry: Proposes a solution, but the approach is reviewed and approved by a Senior Developer.
• Mid: Chooses the technical approach for routine problems or small-to-medium tools, consulting a Senior Developer for complex integrations or new technologies.
• Senior: Defines the technical approach and architecture for complex, multi-system tools, making key technology choices and setting standards.
• Type: Scope & Feature Prioritisation
• Entry: Executes features as defined by the Senior Developer or Lead; escalates any scope creep.
• Mid: Prioritises features within an assigned project, pushing back on non-essential requests, but consults with stakeholders and manager on major scope changes.
• Senior: Negotiates scope and prioritisation directly with business stakeholders, making trade-off decisions to meet business goals.
• Type: Database Schema Design
• Entry: Modifies existing schemas with direct guidance; does not design new ones independently.
• Mid: Designs new database schemas for individual tools, seeking review from a Senior Developer or Lead for best practices and performance.
• Senior: Governs data models for multiple internal systems, making decisions on database technology and integration strategies.
• Type: Tool Deployment & Infrastructure
• Entry: Uses existing CI/CD pipelines and deployment scripts under supervision.
• Mid: Deploys tools independently using established CI/CD pipelines; troubleshoots deployment issues; proposes minor improvements to deployment processes.
• Senior: Designs and implements new CI/CD pipelines and deployment strategies for internal platforms, optimising for reliability and cost.

Competency Requirements

Foundation Skills (Transferable)

Beyond the technical wizardry, you'll need a solid set of human skills to succeed here. These are the things that help you work with people, solve problems, and keep things moving, even when the data's messy or the requirements are vague.

• Category: Communication & Collaboration
• Skills: Active Listening: Genuinely hearing and understanding user problems, not just waiting to speak.
• Clear Explanations: Translating technical concepts into plain English for non-technical colleagues.
• Written Communication: Crafting clear emails, documentation, and project updates.
• Feedback Incorporation: Taking on board constructive criticism from code reviews and user testing.
• Category: Problem-Solving & Analysis
• Skills: Root Cause Analysis: Digging beyond the symptom to find the actual problem a user is experiencing.
• Logical Thinking: Breaking down complex problems into smaller, manageable pieces.
• Structured Approach: Following a clear process to diagnose issues and develop solutions.
• Trade-off Evaluation: Understanding the pros and cons of different technical solutions.
• Category: Adaptability & Resilience
• Skills: Handling Ambiguity: Comfortably working with incomplete information and vague requirements.
• Prioritisation: Juggling multiple requests and knowing what to work on next when things shift.
• Learning Agility: Quickly picking up new technologies, frameworks, or business processes.
• Dealing with Frustration: Staying calm and focused when encountering messy data or unexpected bugs.

Functional Skills (Role-Specific Technical)

These are the specific methodologies, concepts, and approaches you'll use day-to-day. It's about how you think about building tools and solving business problems, not just the code you write.

Technical Competencies

• Skill: Business Process Automation (BPA)
• Desc: The ability to look at a manual, human-driven workflow (like 'Sales Ops needs to manually approve new trial accounts'), map it out step-by-step, and then translate that into a reliable, automated system. It's about making things faster and less error-prone.
• Level: Intermediate
• Skill: API Integration & Design
• Desc: You'll need to know how to use existing third-party APIs (think Salesforce, Stripe, Slack) to pull and push data. You'll also be designing simple, effective internal APIs that act as the 'glue' between our different systems, making sure they can talk to each other cleanly.
• Level: Intermediate
• Skill: Internal UX/UI Design
• Desc: This isn't about making things look beautiful for external customers; it's about making internal tools super efficient and clear for your colleagues. It means creating interfaces that prevent errors, reduce cognitive load, and generally make their jobs easier. Think 'pit of success' design.
• Level: Basic
• Skill: Requirements Gathering & Refinement
• Desc: The knack for interviewing non-technical colleagues, taking their vague requests ('this report is too slow') and turning them into specific, actionable technical requirements. It also involves managing scope creep, so you don't end up building the whole kitchen sink.
• Level: Intermediate
• Skill: Data Modelling
• Desc: Structuring data in a logical way for a specific application. Often, this means creating 'shadow' tables or mini data marts that simplify complex production data for a tool's specific purpose, making it easier to work with.
• Level: Intermediate
• Skill: Rapid Prototyping
• Desc: The ability to quickly build and deploy a v0.1 of a tool to get immediate user feedback. This often involves using low-code platforms to test ideas before committing to a full-scale custom build. It's about getting something working fast.
• Level: Intermediate

Digital Tools

• Tool: Python (Flask)
• Level: Intermediate
• Usage: Building and modifying backend API patterns, writing scripts to move and transform data between systems.
• Tool: React.js
• Level: Intermediate
• Usage: Modifying existing frontend components, building simple user interfaces for internal tools using component libraries.
• Tool: Retool / Appsmith
• Level: Intermediate
• Usage: Building and maintaining basic CRUD interfaces and dashboards quickly, using drag-and-drop components and custom JavaScript/SQL to extend functionality.
• Tool: PostgreSQL / MySQL
• Level: Intermediate
• Usage: Writing complex SELECT/INSERT/UPDATE queries, designing basic schemas, and optimising queries for internal tool databases.
• Tool: Docker
• Level: Basic
• Usage: Using existing Dockerfiles to run applications locally for development and testing.
• Tool: Git / GitHub
• Level: Intermediate
• Usage: Managing branching strategies, performing code reviews for peers, resolving merge conflicts, and contributing to CI/CD pipelines.

Industry Knowledge

• Area: Software Development Life Cycle (SDLC)
• Desc: Understanding the full process from requirements gathering, design, development, testing, deployment, and maintenance. You'll be involved in most of these stages for your projects.
• Area: Agile Methodologies
• Desc: Familiarity with Scrum or Kanban, participating in stand-ups, sprint planning, and retrospectives. We work in an iterative way, so understanding this is key.

Regulatory Compliance Regulations

• Reg: General Data Protection Regulation (GDPR)
• Usage: Understanding the basics of data privacy and ensuring any internal tools handling personal data are compliant with our company's GDPR policies. This means knowing what data you can store and how.
• Reg: Internal Security Policies
• Usage: Adhering to our company's security best practices, especially regarding data access, authentication, and authorisation for internal tools. You'll need to ensure your tools don't create security vulnerabilities.

Essential Prerequisites

• At least 2 years of professional experience as a developer, ideally working on web applications or internal systems.
• Solid understanding of at least one backend language (Python or Node.js preferred) and one frontend framework (React.js).
• Experience with relational databases (PostgreSQL or MySQL) and writing SQL queries.
• Demonstrable experience with Git for version control and collaborative development.
• A portfolio or examples of previous work (even personal projects) that showcase your ability to build functional applications.
• Experience working directly with non-technical stakeholders to gather requirements.

Career Pathway Context

These are the foundational skills and experiences we expect you to bring to the table. If you've got these covered, you're in a great spot to hit the ground running and quickly start making a real impact. We're looking for someone who's already comfortable building things and is ready to take on more ownership.

Qualifications & Credentials

Emerging Foundation Skills

• Skill: Prompt Engineering & LLM Integration
• Why: Honestly, competitors are already using AI to draft reports in 10 minutes that used to take 2 hours. Developers who figure out how to effectively use Large Language Models (LLMs) will outproduce their peers significantly. This isn't just for content; it's for code, data analysis, and documentation.
• Concepts: [{'concept_name': 'Context Windows & Token Limits', 'description': 'Understanding how much information an LLM can process at once and how to manage it efficiently.'}, {'concept_name': 'Temperature Settings', 'description': 'Knowing when to make an LLM creative (high temperature) versus precise (low temperature) for different tasks.'}, {'concept_name': 'RAG Architectures', 'description': 'Retrieval Augmented Generation – how to connect LLMs to our own internal, proprietary data for accurate, context-aware responses.'}, {'concept_name': 'Output Validation & Hallucination Detection', 'description': "Critically evaluating LLM outputs to ensure they're accurate and not making things up – because they do that sometimes."}, {'concept_name': 'Prompt Chaining', 'description': 'Breaking down complex tasks into a series of smaller, interconnected prompts for more robust automation.'}]
• Prepare: This week: Set up GitHub Copilot or a similar AI coding assistant and commit to using it for every piece of code you write.
• This month: Build one small automated report or data summary using an LLM API (e.g., OpenAI, Anthropic) for an internal team.
• Month 2: Research and implement a basic RAG architecture to connect an LLM to a small internal knowledge base.
• Month 3: Document your productivity gains and share your learnings with the team during a tech-talk.
• QuickWin: Start using Claude or ChatGPT to draft email summaries, generate code comments, or brainstorm API designs today. No approval needed, immediate benefit.
• Skill: Observability & Monitoring
• Why: As our internal tools become more critical, knowing *why* something broke and *how* it's performing is essential. We can't afford to wait for a user to tell us something's down. Proactive monitoring means less downtime and happier users.
• Concepts: [{'concept_name': 'Logging Best Practices', 'description': "Structuring logs so they're actually useful for debugging, not just a wall of text."}, {'concept_name': 'Metrics Collection', 'description': 'Identifying key performance indicators (KPIs) for your tools and collecting them automatically (e.g., request latency, error rates, user counts).'}, {'concept_name': 'Alerting Strategies', 'description': "Setting up smart alerts that tell you when something's genuinely wrong, without creating 'alert fatigue'."}, {'concept_name': 'Distributed Tracing', 'description': 'Following a request through multiple services to pinpoint where bottlenecks or errors occur in complex systems.'}, {'concept_name': 'Dashboarding & Visualisation', 'description': 'Creating clear, actionable dashboards that show the health and performance of your tools at a glance.'}]
• Prepare: This week: Review the logging in one of your existing tools and improve it to include more context.
• This month: Set up basic metrics collection (e.g., using Prometheus/Grafana or cloud provider tools) for a new tool you're building.
• Month 2: Implement an alert for a critical error condition in one of your tools and test it.
• Month 3: Create a simple dashboard to visualise the key metrics for your most used internal tool.
• QuickWin: Add structured logging to any new feature you build this week. It's a small change with big future benefits.

Advancing Technical Skills

• Skill: Advanced Frontend Development (TypeScript & Design Systems)
• Why: As internal tools become more complex and numerous, maintaining consistency and scalability in the user interface is crucial. TypeScript helps catch errors early, and design systems speed up development while ensuring a unified user experience.
• Concepts: [{'concept_name': 'Type Safety', 'description': 'Using TypeScript to prevent common JavaScript errors at compile time, leading to more robust applications.'}, {'concept_name': 'Component Libraries', 'description': 'Building and using reusable UI components (e.g., buttons, forms, tables) to accelerate development and ensure consistency.'}, {'concept_name': 'State Management', 'description': 'Mastering patterns like Redux or React Context API for managing complex application state efficiently.'}, {'concept_name': 'Accessibility (A11y)', 'description': 'Ensuring internal tools are usable by everyone, including colleagues with disabilities, which is often overlooked but critical.'}]
• Prepare: This quarter: Convert a small React component to TypeScript and understand the benefits.
• Next quarter: Explore an existing component library (e.g., Material-UI, Ant Design) and use it for a new UI feature.
• Within 6 months: Propose and start contributing to a small internal component library for common UI elements.
• Within 9 months: Take an online course on advanced React patterns or TypeScript best practices.
• QuickWin: For your next React project, start with a TypeScript template. The IDE will guide you through it.
• Skill: Cloud-Native Deployment & Serverless Functions
• Why: Our infrastructure is moving more and more to the cloud. Understanding how to deploy and manage applications using cloud-native services means more scalable, cost-effective, and easier-to-maintain tools. Serverless functions are perfect for many internal automation tasks.
• Concepts: [{'concept_name': 'AWS Lambda / GCP Cloud Functions', 'description': 'Writing and deploying small, event-driven functions without managing servers.'}, {'concept_name': 'Containerisation (Docker & ECS/Kubernetes basics)', 'description': 'Packaging applications into portable containers and deploying them efficiently on cloud platforms.'}, {'concept_name': 'Infrastructure as Code (IaC) basics', 'description': 'Defining infrastructure (servers, databases, networks) using code (e.g., Terraform, AWS CloudFormation) for consistency and repeatability.'}, {'concept_name': 'Cloud Security Best Practices', 'description': 'Understanding IAM roles, security groups, and other cloud security concepts to keep your tools safe.'}]
• Prepare: This quarter: Deploy a simple Python Flask API as an AWS Lambda function.
• Next quarter: Learn the basics of Docker and containerise one of your existing applications.
• Within 6 months: Explore a simple IaC tool like Terraform to provision a small cloud resource.
• Within 9 months: Take an AWS Certified Developer or Google Cloud Associate Cloud Engineer course.
• QuickWin: Try deploying a small script you already have as a serverless function. It's often quicker than you think.

Education Requirements

• Level: Minimum
• Req: A Bachelor's degree in Computer Science, Software Engineering, or a related technical field.
• Alts: We're pragmatic here. If you've got equivalent practical experience, a coding bootcamp certificate, or a strong portfolio of projects that shows you can do the job, we're definitely interested. We value proven ability over a piece of paper.

Experience Requirements

You'll need roughly 2-5 years of professional experience as a software developer, ideally with a focus on web applications, backend services, or internal tools. We're looking for someone who's comfortable taking ownership of projects, has shipped real code, and has experience working with different teams to understand their needs. Experience with both frontend and backend development is a big plus, as is any exposure to low-code platforms.

Preferred Certifications

• Cert: AWS Certified Developer - Associate
• Prod: Amazon Web Services (AWS)
• Usage: Shows a solid understanding of cloud development practices, which is increasingly relevant for our internal tools infrastructure.
• Cert: Professional Scrum Developer (PSD)
• Prod: Scrum.org
• Usage: Demonstrates a strong grasp of agile development principles, which is how we work here.

Recommended Activities

• Attending relevant tech meetups or conferences (we'll cover the costs, usually).
• Taking online courses on new frameworks, cloud services, or AI development.
• Contributing to open-source projects, especially if they align with our tech stack.
• Participating in internal hackathons or 'innovation days' to experiment with new ideas.
• Mentoring junior developers or new joiners, even informally – it's a great way to solidify your own knowledge.

Career Progression Pathways

Entry Paths to This Role

• Path: Junior Developer (Internal or External)
• Time: 2-3 years
• Path: Full-Stack Developer (Small Company/Startup)
• Time: 2-4 years
• Path: IT Support / Systems Administrator with Scripting Skills
• Time: 3-5 years

Career Progression From This Role

• Pathway: Senior Internal Tools Developer (L3)
• Time: Roughly 3-5 years in this role

Long Term Vision Potential Roles

• Title: Staff Internal Tools Developer (L4)
• Time: 5-8 years from current role
• Title: Internal Tools Developer Manager (L5)
• Time: 7-10 years from current role
• Title: Principal Engineer, Internal Platforms (L5)
• Time: 8-12 years from current role

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.