Overview

From March 2022 through January 2023 at Paperless Parts, I served as the lead product designer for Integration Actions, a powerful integrations framework that helps users understand their integrations capabilities, interact with them, diagnose issues to receive instantaneous support, and build custom integrations with other external software. They also help the Paperless Parts team access, configure, build, and deploy custom integrations with ease.

Since launch, this feature set powers over 250 novel integrations, helped scale Paperless Parts’ customer base by over 4x and unlocked over $1M in upsell from customization requests and custom integrations pricing plans, and has powered Paperless Parts’ strategy of becoming the API hub for the manufacturing industry.

Background

Paperless Parts--a cloud-based manufacturing quoting SaaS startup--is successful because of integrations with decades-old, custom-configured, on-premise Enterprise Resource Planning (ERP) software used by job shops to manage their businesses. In Paperless Parts’ first four years, integration engineers worked directly with customers to address needs and build behavior; and their fast pace of development meant each integration was a “black box” that only those engineers--not the shop users--could access, see activity for, and diagnose issues with.

However, as Paperless Parts’ customer base grew rapidly in early 2022, integrations became the biggest bottleneck for getting customers live. Integrations engineers were overworked and improperly prioritized--spending too much time with customers handling requests, generating activity resorts, and diagnosing issues instead of developing integrations--and the other teams at the company couldn’t help.

At the same time, shop-contracted integration developers sought to build integrations on top of Paperless Parts, but found that Paperless Parts users strongly resisted using multiple systems and wished they could interact with their external software directly within the platform.

Discovery

While this project’s impetus was internal, I believed there was an opportunity to solve adjacent customer needs as a way to address our own--so I sought to understand both internal teams’ and customers’ experiences with integrations.

Internally

Through a series of rigorous interviews with our integrations, support, and implementation teams, I identified the following challenges:

  1. The integration team didn’t have sufficient separation from customers and prospects.
    Because integrations were a “black box” of functionality, integration engineers were forced to own customer relationships in sales calls and for support and customization requests directly, robbing them of valuable development time.
  2. The sales team didn’t have sufficient leverage to deny customization requests.
    Because integrations didn’t have a demo-able user interface that could be promoted as “standardized”, every customer’s customization requests were treated as integral to their sale, instead of upsold as additional work.
  3. The support and configurations teams were underutilized.
    Because integration setup and connectivity were deeply intertwined with integration code, even for pre-built integrations without customization requests, our support team couldn’t assist with integration setup.

With customers

Through a series of customer interviews with various stakeholders at job shops of various scales and production types, I found:

  1. Shop managers were unable to audit syncing and identify failures.
    Without integration logs, shop managers often only identified syncing failures days later while browsing their ERP system, delaying critical purchasing and production work.
  2. Shop managers couldn’t manually sync information or remedy issues themselves.
    Job shop managers often had to wait hours for the Paperless Parts support team to request a re-sync after an issue, despite often being able to solve the issue themselves.
  3. Custom integration developers struggled to provide logging and interactivity, too.
    Shops’ in-house software teams or 3rd-party developer consultants similarly were unable to easily provide shop managers logging or the ability to manually resolve issues, too.

Synthesis

Reviewing both stakeholders’ feedback together, I quickly realized that both our internal and custom problems could be solved if we developed a user-facing integration framework instead of an internal tool.

By giving shop managers a simple integration activity logging interface and tools for manually requesting integration syncing, we could significantly reduce Paperless Parts’ support team’s involvement in auditing and resolving integration issues.

Design

Designing for specific user personas

Although I hoped to design a single set of interfaces that could help all customer and internal stakeholders, I still sought to understand each user persona’s unique needs and design for them.

Specifically, I identified 7 unique personas:

  1. Job shop managers needed to audit integration activity en masse and diagnose system issues--so I designed a high-density activity log view with robust filtering.
  2. Job shop salespeople facilitating orders needed to ensure their work synced with their ERP--so I designed access to the integration directly from an order, with activity logs and action requests scoped to that order.
  3. Job shop IT managers wanted to quickly configure their on-premise connection without sharing credentials with Paperless Parts support. To enable this, I provided a simple step-by-step setup experience within Paperless Parts that ensured each step was completed successfully and explained how to resolve issues if not.
  4. Custom integration developers wanted to quickly build user interaction and logs for their integration without custom interface development or scheduling automated activity. To enable this, I designed the integration manager to be agnostic to the software it was integrating with and highly configurable, as well as designed a simple activity scheduling module.
  5. Paperless Parts’ sales engineers wanted to demo our integration behavior as standardized--so I ensured that in-house integrations were presented with Paperless Parts branding (despite using the same software-agnostic UI as custom integrations) and provided easy-to-understand descriptions for each available action.
  6. Paperless Parts configuration and support specialists wanted to be able to browse and resolve integration failures, answer customer questions, and address customer security breaches without engaging integration engineers. To enable this, I ensured that they could access the same integration logs as customers; that integration failure messages were highly descriptive and human-readable; and that Paperless Parts team members could disable all integration activity with a single action.
  7. Paperless Parts integration engineers wanted to avoid all customer interaction while being able to diagnose issues and quickly push updates to the on-premise integration. Alongside enabling them and other teams to browse integration activity, I enabled this by providing the ability to open a limited-duration VPN tunnel to the on-premise software connector right from Paperless Parts, allowing engineers to push and test updates without violating security compliance guidelines.

Understanding each of these personas led me to create a clear division between the user-facing integration manager, which allows users to browse integration activity and request actions, and the integration-developer or Paperless-Parts-team-only integration configuration experience.

Additionally, ensuring the feature met every persona’s unique needs contributed to every aspect of the feature’s success, including enabling integration customization upsells, eliminating integration engineers’ interactions with customers, and enabling both customers and the support team to diagnose and resolve integrations syncing failures.

Taking inspiration from existing software

To ensure my UX would both appear professional and be highly usable, I sought inspiration from existing enterprise-grade software, then mapped portions of each back to my personas to ensure I applied their visual paradigms only where applicable.

Software features I drew inspiration from include:

  1. Stripe’s API activity logs for the job shop manager’s activity logs
  2. Stripe’s API key interfacefor the custom integration developer’s API key configuration
  3. Zapier’s external software credential entry for the IT manager’s on-premise credential entry
  4. Productboard’s “push to JIRA” action for the job shop salespeople’s manual sync action

Taking inspiration from these platforms ensured our technologically-savvy customers and 3rd-party integration developers were able to quickly adopt the feature set.

Leveraging our design system

For the portions of our feature requiring a completely novel UI, I continued to rely on Paperless Parts’ Cube Design System that I previously founded, using our standardized components and rules for tabs, tables, actions menus, forms, and disabled states to ensure novel experiences would be quickly understood.

Using established UX patterns and components ensured even the most original portions of our feature, like the action scheduling module, are highly utilized by custom integration developers today.

Validating with prototype interviews

To validate my interfaces, especially with technology-averse job shop employees, I designed a high-fidelity interactive prototype in Figma to walk through in UX interviews. I took particular care to build in customization, so I could map the specific integration text, logos, and action content to realistic content for each interview to minimize our interviewee’s confusion.

This prototype ensured we got specific, tangible feedback about gaps in our proposed feature, contributing to additions to the eventual launch. It also helped our team capture strong user demand when our interviewees--believing the prototype was real--asked if they could have the feature turned on for their accounts immediately!

Results

Since launch, the integration actions framework has been a massive success. Not only have our internal team members and customers praised how much easier it makes their lives--given they can now self-service any potential issues on either side--but it has also helped Paperless Parts grow rapidly, supported upsell, and is now powering Paperless Parts’ strategy of becoming a central hub API for job shop manufacturers.

Metrics

  1. Powers 250+ integrations across ~30% of Paperless Parts’ customer base
  2. Drove a 4x expansion in Paperless Parts’ customer base from 2022-2023
  3. Unlocked > $1M in upsell from custom integrations pricing plans
  4. Captured and helped users audit 1.9 million actions over two years
  5. Helps retain millions of dollars in ongoing business