AFG - Designing for Complex Ownership Structures

Simplifying how brokers create and manage companies and trusts applicants within a complex financial services workflow.

At AFG, I led end-to-end product design for a complex financial services feature supporting companies and trusts with interconnected applicant structures.

Working within an agile product environment, I partnered continuously with Product Owners, Business Analysts, Subject Matter Experts and Engineers to move the work from an ambiguous problem space through iterative discovery, workflow modelling, interaction design, prototyping and delivery.

Role: Senior UX/UI Designer
Industry: Financial Services / Fintech
Scope: Discovery to Delivery
Focus: Enterprise UX, Complex Workflows, Interaction Design, Design Systems
Collaboration: Product, BA, SMEs, Delivery and Engineering

The Challenge

What initially appeared to be a straightforward workflow quickly revealed a complex system of entity types, relationships, business rules and downstream dependencies.

Companies and trusts could involve different applicants, roles and ownership structures. The experience needed to support these variations without exposing the full complexity of the underlying system to brokers. The challenge was clear:

“

How might we support complex financial structures while keeping the experience clear, predictable and scalable?

Discovery Through Delivery

Discovery was not a phase that ended before design began.

The project started with a broad and ambiguous problem space. Working closely with Product Owners, Business Analysts and Subject Matter Experts, I progressively built clarity around entity relationships, business rules, user scenarios and workflow dependencies.

The discovery process was funnel-shaped. Broad domain questions gradually narrowed into workflow decisions, interaction patterns and specific edge cases.

As clarity increased, discovery became more focused. New insights from prototypes, stakeholder reviews and implementation fed back into the design process.

“

Discovery continued throughout delivery, becoming more focused as uncertainty reduced.

This approach allowed the team to move forward without pretending every requirement was known upfront.

Making Complexity Visible

Before designing the interface, I needed to understand the system behind it.

I mapped entity types, relationships, alternate pathways and downstream dependencies across the application journey. This helped expose hidden assumptions and gave Product, Business Analysis, Design and Engineering a shared model of the problem.

The mapping revealed three connected layers of complexity:

Entity structure
Who or what is involved?

Relationships
How are people, companies and trusts connected?

Workflow state
What already exists, what can be reused and what needs to happen next?

From System Model to User Experience

With greater clarity around the domain, I translated the system model into a scalable interaction model.

Rather than designing isolated flows for every entity type, I identified common behaviours that could become reusable patterns across the product:

• finding and reusing existing records
• creating new entities
• defining relationships
• communicating system status
• handling alternate pathways
• returning users to the wider application journey

The goal was consistency without oversimplification. Common behaviours should feel familiar, while genuine differences in business rules still needed to be respected.

Prototype, Learn, Refine

Flows, wireframes and interactive prototypes were used as discovery tools, not simply design outputs.

Working with POs, BAs and SMEs, I walked through realistic scenarios to challenge assumptions and test how the interaction model behaved across different entity structures.

Each iteration helped uncover missing states, edge cases and unclear relationships.

Designing for Scale

As the experience matured, I applied consistent information hierarchy, progressive disclosure, reusable interaction patterns and clear system feedback.

The feature also contributed to broader design-system maturity through reusable components, semantic design tokens and accessibility considerations.

I worked closely with Engineering to ensure that interaction patterns were scalable, technically feasible and aligned with the wider product ecosystem.

Agile Collaboration and Delivery

Design progressed alongside agile delivery rather than as a separate upstream activity.

I worked continuously with:

• Product Owners to align experience decisions with product priorities.
• Business Analysts to clarify business rules and workflow requirements.
• Subject Matter Experts to validate domain logic and complex scenarios.
• Engineers to assess feasibility, resolve implementation constraints and maintain design intent.

Discovery continued into implementation as new edge cases and technical considerations emerged. Rather than treating the design as a fixed specification, we worked through trade-offs collaboratively while protecting the core experience.