Three Months with Testfully
The LinkedIn Notification That Rewrote My Career
September 2024. A notification I almost ignored.
Matt Vally, founder of Testfully, was looking for a UI/UX designer. Another startup, another API tool, another "we're different" pitch.
Except this one actually was different.
Our first conversation revealed something I hadn't expected - Matt wasn't looking for someone to make his existing product prettier. He needed someone to understand enterprise developers' pain at a fundamental level.
The 45-minute whiteboard session humbled me. Design a license management module for enterprise clients. Boeing-level complexity. Pearson-scale stakes.
I didn't nail it. The solution was incomplete, the complexity overwhelming.
But Matt saw something I was still learning to recognize in myself - the willingness to sit with uncertainty, to admit when I didn't know something, to dig deeper instead of defaulting to familiar patterns.
"Fair job for the time given," he said. Three words that became my contract.
Joining a Two-Person Revolution
Testfully wasn't just competing with Postman - it was challenging an entire philosophy of software design.
Where others added features, Matt subtracted complexity. Where others chased every user, he served enterprise developers with precision.
I inherited a design system with good bones but unclear direction. More importantly, I inherited direct access to users who wouldn't sugarcoat feedback. Enterprise developers don't have patience for interfaces that waste their time.
This wasn't about making something look professional. It was about making something work under pressure.
The Humbling Learning Curve
Our first target: the API request form. The heart of any testing tool.
There was one problem - I didn't truly understand APIs beyond surface level.
This moment taught me something crucial about growth: you can't design what you don't understand. Not really.
So I became a student again.
ChatGPT became my patient tutor. Developer friends endured my basic questions. I spent hours in Postman, APIdog, every tool I could find, not as a designer studying interfaces, but as a user trying to accomplish real tasks.
I tested free APIs, broke things, got confused, started over. Each frustration taught me something about the developer experience I was designing for.
The learning wasn't just technical. It was empathetic. I began to feel the cognitive load developers carry, the context switching, the precision required.
This wasn't research. It was transformation.
The Clarity Breakthrough
User feedback sessions with Matt revealed our core challenge: "Users can't tell what goes where. The input fields aren't communicating."
But I heard something deeper - we weren't just fixing a form, we were designing trust.
When a Boeing developer is testing critical systems, interface confusion isn't just frustrating. It's risky.
This realization shifted everything. Instead of polishing existing patterns, we embraced rapid iteration. Rough sketches before refined mockups. Understanding before aesthetics.
Matt and I moved at startup velocity - two people, zero bureaucracy, pure focus on solving the right problems.
The breakthrough came when we stopped asking "How do we make this look better?" and started asking "How do we make this feel obvious?"
Wrestling with Complexity
Just as we solved the request form, Testfully's unique challenge emerged: multiple requests on the same interface.
The request side was complex enough. Multiple responses? That was exponentially harder.
Here's where I learned about startup pragmatism. We could spend months perfecting the multi-response experience, or we could ship the improved request form and learn from real usage.
We chose learning over perfection. Ship, gather feedback, iterate. Not because we accepted mediocrity, but because we understood that perfect solutions often come from imperfect starts.
This taught me something profound about design maturity - knowing when to embrace the imperfect to discover the ideal.
Expanding Beyond Forms
With the core experience improving, our scope grew: navigation systems, folder structures, information architecture that made sense to enterprise minds.
I even stretched into content design, creating YouTube thumbnails and blog templates for Testfully's storytelling.
For three months, we moved fast, learned faster, and built something that enterprise developers actually wanted to use daily.
The Unexpected Pause
Personal health challenges forced me to step back. Not the ending I'd planned for this story.
But those three months transformed how I approach design problems. I learned that understanding your users' world isn't optional research - it's foundational empathy. That rapid iteration isn't about cutting corners - it's about learning efficiently. That enterprise design isn't about adding complexity - it's about organizing it meaningfully.
What This Experience Taught Me
Technical depth changes design decisions. Every hour I spent learning APIs influenced interface choices in ways I couldn't have anticipated. Designing from ignorance versus designing from understanding produces fundamentally different outcomes.
Rapid iteration reveals truth faster than perfect planning. In a two-person team competing with industry giants, speed and adaptability weren't just advantages - they were survival skills.
Enterprise users need clarity, not simplicity. The difference is crucial. Boeing developers don't want dumbed-down tools - they want complex capabilities presented clearly.
Sometimes the biggest design challenge isn't visual - it's communication. That API form wasn't broken because it looked bad. It was broken because it didn't guide users effectively.
Growth happens in discomfort. Taking on API design without deep technical knowledge forced learning that made me a fundamentally better designer.
Looking back, I wouldn't change the rapid-learning, high-pressure approach. It taught me things no amount of comfortable projects could have. The scrappy, figure-it-out-as-you-go method revealed capabilities I didn't know I had.
The most rewarding part? Knowing that somewhere, an enterprise developer's workflow is slightly more intuitive because of decisions we made in those fast-moving iteration sessions.
Design isn't about the designer. It's about the people whose problems we have the privilege to solve.