Examples of Team Leadership

Summary

I’ve consistently bridged the gap between design, development, and product management to streamline processes, clarify priorities, and deliver impactful results. By proactively addressing pain points—whether it’s balancing workloads, refining documentation, or unifying feature priorities—I’ve helped teams operate more efficiently and align on shared goals.

The examples below demonstrate my ability to create scalable systems, adapt to evolving priorities, and foster cohesive teamwork at various levels—design team, larger UX team (containing design and front-end development), feature team, and entire Product team at Inxeption.

1. Balancing sprint assignments

SCOPE: UX team • TYPICAL TOOLS USED: Google Sheets, Jira

As our UX team of five designers and five front-end developers grew to support more feature teams, it became unclear who was working on what. Design requests were either skipped and brought up last minute or came with vague questions like, "What's your bandwidth?" To address this, I created a sprint-based assignment spreadsheet to clarify workloads and facilitate planning.

I asked Product Management to share desired work and high-level ideas before each sprint, enabling the director of front-end development and me to assign story point estimates. By summing story points and assessing capacity (accounting for PTO or other factors), we determined what fit above the "waterline" and allowed PMs to adjust priorities as needed. The spreadsheet streamlined resource allocation, balancing story points across team members and integrating design and front-end work. This process is documented in the following spreadsheet from 2022.

UX-2022-sprint-planning

2. Post-summit prioritization

SCOPE: Product team • TYPICAL TOOLS USED: Google Sheets, Jira

At Inxeption, our company held a multi-day summit to define our product’s focus. Coming out of the summit, we had the first two tabs of the spreadsheet below, but there was no concrete plan. When I hadn’t received updated goals, I took the initiative to compile a unified list of priorities and coordinate with a senior business leader to ensure alignment. Within two months, our design team had completed most initiatives, largely due to this clear, actionable prioritization (shown in the last two tabs).

202308-product-summit-prioritization-copy-dt

3. Detailed requirements document

SCOPE: Product team • TYPICAL TOOLS USED: Google Docs, Jira, Confluence

A thorough requirements document is critical to ensuring that a design is implemented with the expected visual details and interactions. Our Product group had growing pains as we expanded: every PM had a different story structure and engineers gave feedback that requirements documents were missing use cases, or they didn't realize there was an Adobe XD to refer to, or conversely, there was too much information in paragraphs that obscured the actual requirements, or there was some information in an engineering ticket and other information in a design story.

Together with other team leads, I worked to refine our documentation to increase clarity. After a few years, we settled on a general format, which is shown below from a sample story. Download the full image here (recommend downloading since the image is large and doesn't preview well in the browser). 

Click screenshots to enlarge.

Provide context

To combat the confusion of engineers receiving stories with no context, requirements should have some kind of background, explanation of pain points, and goal of this feature. Optionally, the same can be restated in story format such as "as a [persona], I want [something], so that [goal]" or "Given [conditions], when [trigger], then [outcome]."

Describe the user flow

Especially helpful to PMs and designers when reviewing a spec, and then for QA testers: provide a high-level step-by-step flow through the screens of the implemented feature. 

Explain the prerequisites to get to this step to the degree needed for your audience. Don't over-explain obvious steps or common terms, but include enough so someone could start at the same point you're describing.

On each screen, describe the UI and behavior that you expect to see. If your feature involves multiple actors, name their personas (such as Buyer or Seller or Admin).

Define the scope of dimensions affected

B2B features are affected by "dimensions" that each have variations:

Clearly defining these variations will prevent features from appearing when they aren't supposed to.

List dependencies

In Jira or your ticket system, dependent tickets should be linked, but it also helps to capture any nuances of the dependencies in words. After reviewing and approving these requirements, you may never look at this section again, but at least you included it as a reminder to discuss dependencies and timing during review. 

Show AND tell

The meat of the document should be the requirements. Break them up in whatever way makes the most sense—usually page by page—and then sections within a page. Sometimes, that doesn't make sense, so adapt the breakdown as necessary. For example, you might define different states for the same section if the UI is role-based.

Link to the table of contents page of the Figma or other prototype at the top of the requirements section to give engineers easy access.

Even though you provide mockups and prototypes in Figma or another tool, it can be confusing for engineers to read in one doc and click through a prototype, so include screenshots or prototype embeds along with written expectations. Call attention to portions of the page that need to change.

In the written portion, describe (a) content, (b) styling, and (c) behavior, adjusting the level of detail as necessary. For example, if you're using established components, then don't waste time describing the colors and padding. But if you're modifying an existing component, describe the changes expected. You could provide styling in Figma or other prototyping tool, but depending on your layers and the specific engineer, it may be safer to repeat styling in the document.

To combat the confusion of what is a new feature vs. an update, denote that in bold, visible text.

To reduce the noise of background/historical explanations, preface that info with an ℹ️ icon, which allows engineers and testers to skip over that item while preserving the context for PMs and designers.

Capture open issues

Once the feature is close to completion, any open issues noted in the body of the requirements should be cleared out for clarity. To keep historical knowledge of why the team made a decision—or for questions that don't pertain to a specific portion of a screen—note these questions at the end of the document.

Acceptance criteria

This section can restate at a high level what must be implemented to deem this feature acceptable, focusing on content and behavior, and less on styling.

Technical requirements

The engineering leads typically include technical specifications in a separate section, since no one but them can make use of the information. The information can be useful for the next engineer who fixes bugs or iterates on this feature.

4. Weekly design critique

SCOPE: Design team • TYPICAL TOOLS USED: Google Docs, Slack, Google Chat, Trello

As our design team grew and became embedded in more feature teams, we ran the risk of becoming less unified and losing touch with each others' features. As the team that is tasked with ensuring a cohesive look and feel throughout our platform, we had to guard against this possibility.

To address this risk, I initiated a design review forum that met weekly when possible with the aim of critiquing designs in progress. This process kept us all up to date with the capabilities of our platform, new patterns for specific purposes, and current terminology. It allowed us to identify inconsistencies across the overall user experience before a feature was to be released and practice giving and receiving constructive feedback.

Organizing design reviews didn't need to be complicated. We used a Trello board at first, then moved to a simpler Slack list shown here, before adapting again to changing needs.

5. Tracking feature milestones

SCOPE: Product team • TYPICAL TOOLS USED: Google Sheets

In the fall of 2023, I became the sole platform designer left to support 16 developers, four product managers, and six QA testers while our second designer was on maternity leave. Because I like to be involved in my features, I was struggling to keep track of milestones:

The Product Management organization was stretched thin, juggling competing priorities, and some team members were relatively early in their careers. Recognizing an opportunity to bring order to the design pipeline, I created a comprehensive spreadsheet to track every feature I was aware of over a five-month period. Regularly reviewing the sheet with PMs not only kept me informed about up to 20 features at a time but also encouraged them to adopt and update the tracker themselves. This proactive solution highlights my ability to address pain points effectively and lead by example through detailed, consistent tracking.

2023-24-tracker-dt-copy

6. Organizing sync meetings

SCOPE: Feature team • TYPICAL TOOLS USED: Google Docs, Slack, Google Chat

In 2022, I was assigned to a large group tasked with implementing a business account layer to support features like business payment methods, financing, and consolidated invoicing. The project’s ambitious scope required frequent sync touchpoints. Despite having a VP, project manager, two engineering managers, and two product managers, these meetings often became unfocused, leaving key questions unanswered.

To improve efficiency, I offered to take the lead temporarily. I organized meetings into time-boxed sections, shared agendas in advance, gathered input for discussion topics, and facilitated sessions to ensure all voices were heard. This sample agenda demonstrates the order I brought.

This approach increased topic coverage and ensured the design team had the information needed to perform our work. I ran these meetings for most of the year until we achieved significant milestones and a project manager took over, allowing me to focus on other tasks.

7. Backlog refinement for a project

SCOPE: Feature team • TYPICAL TOOLS USED: Google Sheets, Jira

One of the main projects in 2023 encountered numerous challenges due to loose requirements, lack of prioritization, and frequent turnover of product managers. The epics that captured this project work reflected that turbulent environment. After release, there were many interrelated bugs and stories logged in different projects and epics.

Because I was the only Product team member (of all the designers, product managers, engineers, or testers) consistently participating throughout the project and aware of the full vision, I was driven to help clean up the backlog and provide clear definition for future releases. I found all the tickets through four different queries and unified them into one list shown here, which helped the product manager at the time to define subsequent releases.

8. Providing calculators for testing

SCOPE: Feature team • TYPICAL TOOLS USED: Google Sheets

I like to ensure that a design is implemented as specced, but it can be tough for QA to verify every expectation, especially for tricky calculations. Even though it is typically not a UX task, I utilize my analytical skills when needed to provide spreadsheet calculators that engineers and QA can refer to during implementation and testing. These examples illustrate my commitment to accuracy and supporting the larger org across team boundaries.

Freight Mode Calculator

I created this calculator to determine whether a freight shipment with certain characteristics should be considered a less-than-truckload (LTL) shipment or a full truckload (FTL) shipment at checkout, which affects cost. The decision is based on the shipment's linear footage, which refers to how much of the length of a truck is taken up by a shipment. That calculation depends on the size of a single pallet of the product, how high pallets can be stacked, and whether they can be turned 90º to save space. Engineering and QA could plug in these parameters and verify whether LTL or FTL quotes were correctly returned by the code.

_DT copy of Pallet-calculator-expected-outcomes

Line Item Payment Terms Calculator

This calculator became a much-used resource for engineering and QA when implementing net and monthly payment terms, which could be applied independently for different products in the same quote (called "offers" here), with modifiers such as bulk discounts, offer-level discounts, shipping fee, and storage fee.

Copy of Payment-terms-installment-math

9. Running release retrospectives

SCOPE: Product team • TYPICAL TOOLS USED: Stickies.io, Lucidchart, Miro

Retrospectives are an Agile ceremony that we used semi-regularly at Inxeption. I proposed the format that we used for several years, which is described in the first yellow sticky note below. Project Managment was the main owner of this ceremony. Design does not typically run this ceremony, but because I was senior and trusted enough to run processes for the entire Product org, I stepped in as needed. I ran this particular retro session, which entailed summarizing the release accomplishments (in yellow) to jog everyone's memory, reading every card to ensure clarity, keeping time, and leading the discussion on the top-voted cards to produce goals for future releases (in blue). This sample demonstrates my commitment to iterative improvement and ability to communicate with the entire Product org.