The full toolkit.

After empathy-building sessions I use Dovetail to cluster observations, run thematic analysis and turn raw interview notes into patterns the whole team can act on, without jumping to solutions too early.

I reach for Maze during the empathize phase for quick user interviews and surveys, and again in test for guerrilla and remote usability sessions when I need fast feedback on a prototype before committing to a full lab study.

When I need to distribute a survey beyond a handful of interviewees, covering demographics, preferences and behaviours, Forms is the fastest way to reach a representative sample and complement one-on-one empathy work.

In the test and post-launch loop I review usage metrics to validate whether the product is viable and to spot behaviours that deserve deeper investigation through additional user research.

After shipping I use Hotjar to review real interactions, identify friction points and prioritise improvements. It is a cheap complement to formal usability tests when budget or timeline is tight.

I use FigJam for affinity diagramming, journey mapping, stakeholder mapping and ideation warm-ups, especially when the project team needs to cluster research findings or map a user journey together in define and ideate.

For complex projects I organise content into entity-relationship diagrams and navigation flows that developers can review and extend, keeping ideation grounded in technical feasibility.

In ideate I sketch on a blank canvas to explore multiple design directions at low cost. The roughness invites honest feedback from teammates who might hold back on a polished digital prototype.

Throughout every phase I use Slack to share research findings, coordinate workshops and keep stakeholders updated, especially after story-share-and-capture sessions when the team needs to stay aligned on user insights.

When I cannot respond immediately to a call or message, a Loom walkthrough of a prototype or audit findings reduces interruptions and keeps the team moving without me becoming a bottleneck.

For moderated remote usability tests, design reviews and stakeholder workshops I rely on Teams when the client ecosystem standardises on Microsoft, keeping empathy and alignment sessions accessible across locations.

In UX exploration I use BMAD to scaffold AI-assisted ideation and documentation, accelerating synthesis while keeping outputs aligned with user needs and business goals.

When prototyping AI-assisted workflows I reference SkillsMP patterns to define what an agent should and should not do, keeping explorations scoped and testable.

I build prototypes to test with users and to support design reviews, demonstrating navigation and interaction flows to PMs and developers. A polished Figma prototype is also my best ally when persuading clients or handing designs over to dev teams.

Alongside Figma I use XD for hi-fi prototypes when a team or client already works in the Adobe ecosystem, especially for demonstrating flows during design reviews and early funding conversations.

While crafting hi-fi screens I run contrast and accessibility checks so the product meets web and mobile accessibility guidelines. This is particularly important when adopting a standard design system.

In UI design I use Coolors to explore and refine colour systems that support hierarchy and readability, before locking tokens into a design system.

When a coded prototype is cheaper than a pixel-perfect mockup, or when the design will evolve with user feedback, I use GitHub to manage changes and collaborate with developers on implementation details.

On projects that do not follow a full agile workflow I track activity completion in spreadsheets to ensure we stay within scope, complementing the sprint backlog in Jira when both rhythms coexist.

For design systems I use Storybook so designers and developers work from the same component patterns, reducing drift between Figma specs and shipped UI.

I publish design system guidelines and component specs in Zeroheight for handoff, so developers have a single source of truth beyond the prototype, especially for tokens, patterns and usage rules.

When defining cloud architecture for a new product I collaborate with architects on AWS-based three-layer setups, aligning user needs, scalability requirements and business objectives beyond the interface alone.

On enterprise engagements I work with Azure when the client stack or compliance requirements standardise on Microsoft, ensuring the cloud architecture supports the user experience we are designing.

For coded prototypes and headless CMS-backed sites I deploy on Vercel to get a shareable URL quickly, useful for live prototype tests and stakeholder reviews without a full release cycle.

I use Directus when a product needs a flexible content layer, pairing it with a modern frontend so editors and designers can iterate without redeploying the whole application.

With an engineering background I write Bash scripts to automate build steps, seed content and glue together cloud services, keeping design explorations connected to how things actually ship.

I use Claude to accelerate research synthesis, explore product directions and draft documentation, always cross-checking outputs against real user insights and technical feasibility.

When exploring AI-native product concepts I prototype with OpenAI models to test interaction patterns and validate whether an AI feature genuinely solves a user need before investing in production infrastructure.

For AI design explorations I browse Hugging Face to evaluate models and capabilities that might fit a product concept, especially when future-thinking workshops surface emerging technology opportunities.

I wire up N8N flows to prototype automations, from research ingestion to handoff notifications, so stakeholders can experience an end-to-end process before committing to custom engineering.

I use Notion for handoff docs covering information architecture, navigation flows and component behaviour, supported by prototype visuals. It reduces interruptions from colleagues and forces me to self-assess how each part of the design should work.

In my daily project management I plan sprints and populate the backlog in Jira, translating user stories, acceptance criteria and design tasks into work the whole team can track.

When documentation needs to be printed or formally signed off I create blueprint documents in Word, while keeping day-to-day collaborative specs in web-based tools like Notion.

With a computer science background I sometimes find it cheaper to code a working interface in Vue than to mock every state in Figma, especially for data-heavy dashboards and interactive flows.

I reach for React when a coded prototype needs rich interactivity or when handing off to a team that standardises on the React ecosystem, bridging design intent and implementation.

For mobile-first products I prototype or spike features in Swift when native behaviour, gestures or platform conventions matter more than a cross-platform mockup can convey.

On .NET-heavy engagements I use C# to validate technical feasibility early, collaborating with developers on APIs and data models that shape what we can realistically design.

When information architecture touches complex data relationships I write SQL to explore schemas and validate whether the UI patterns we are designing map to real data constraints.