Designing Bioprocess
What I've learned from a year of designing software for scientists
Emmet Blanchette // November 2026
When you can build anything, what do you build?
I joined Ark at a pivotal moment for software. From day one I worked closely with my team of scientists and engineers to dream up the best products for our users—and then built them, moving between define, design, build, and test, not always in that order. I'm fortunate to have grown into the hard-to-define role of Product Designer at Ark and push the envelope on technical scientific platforms.
The product knowledge needed for owning 0 to 1 to 1,000
Our most ambitious features all started as an ambiguous goal and a pharma R&D or manufacturing need. In tight iterative cycles I took them to well-researched, battle-tested, performant tools that scientists use every day. With great product ownership comes a need for great product knowledge: know the most in the room about any feature you ship so you can dependably defend every decision and know when to pivot. This leads naturally to the next learning:
Walk in stupid
Dan Wieden, co-founder of the ad agency Wieden+Kennedy, told his people to "walk in stupid every morning." The longer version:
"When you don't know, you try desperately to find out. But the minute you think you know, the minute you go—oh, yeah, we've been here before, no sense reinventing the wheel—you stop learning, stop questioning, and start believing in your own wisdom, you're dead. You're not stupid anymore, you are fucking dead."
I've learned more than I ever thought I would about cell culture, but I'm still often the least expert person in the room on the science or modeling itself. Though it can work in your favor; not knowing is what lets you ask the question that the experts don't ask anymore. Nobody has anything to gain by pretending they understand, so keep asking the stupid questions until you are genuinely completely clear; it usually uncovers something important.
Be unabashedly comb-shaped
Multi-modal user needs demand multi-modal designers. I lean toward technical execution as opposed to conceptual process, but the payoff of holism became a no-brainer. User research, product design, product engineering, and product marketing all benefit from a familiarity with each other.
Quality control
Shipping fast doesn't have to mean shipping sloppy. Being ready to jump into a branch at a moment's notice, catching consistency errors and bugs before its merged into production the next morning, can sharpen your sense of how much attention a problem needs.
Design feedback and user testing
Scientists are generous and brutally honest testers. Putting early work in front of them (internal or external) was often the wrong approach, because a reaction is only useful when a reaction is what you want. To build technically ambitious and complex product features, you want thoughtful problem statement orientation and definition, not reactions to the interface.
"Feedback is a gift, but there are more things to do than time." This is a quote from Ark's CEO, who is also a fellow Product team member. Feedback triage is a skill that develops hardiness quickly. The crux is this: finding the right time to ask the right person the right question is worth the time it takes. When shipping fast matters, learn to distinguish between surface-level requests and deeper product shortcomings. Let interviewees ramble only if it serves a purpose.
Diverge prolifically, converge ruthlessly
Run wide loops in your process because the one more iteration that nobody asked for might be the one that produces the unexpectedly clever solution. On that note, a reminder that every design student heard countless times in school:
Never. Delete. Anything.
The killed exploration, the abandoned flow, the copy that didn't make the cut: archive it, don't delete it. Old work is the cheapest research there is and it might end up being next cycle's answer. When you struggle to answer a product question, half the time the answer is sitting in a Figma archive page.
Art, science?
Making software work is a science. Making it work well, even. Making good software that works well? Some mixture of both, probably. But guess what, we can argue about science; that's what makes it science. It’s a process that we can adhere to strictly or loosely. Think of art like science that we can point at and give our opinions on.
Engineers are our primary stakeholders
Even though our job is to advocate for the user, building trusting relationships with the engineers on our teams is the path to a better product. Even in the agentic era where we can proverbially or literally open pull requests, we're still beholden to the data structures, frontend frameworks, network infrastructures, and security that are overseen by engineers. It's worth developing both the rhetorical and technical skills that let you incorporate engineers' valuable input and come to shared agreements about product success.
The effort paradox
Big design choices require outsized justification, small ones struggle to make it into prod. The natural next step might be "learn to code or use an agent well and push changes yourself." But then your time is split. The answer: carve out 2–4 days a month for yourself to push the small improvements to maintain your standard of quality.
Who affords whom?
In consumer software, designers offer affordances to users: controls, options, shortcuts, the small courtesies that make a product feel like it's on your side (and reduce the friction to $). In technical and scientific software, I've noticed it has historically been the reverse. Users know they're dealing with a powerful analytics platform, so they extend the affordances to the software. They memorize the workarounds. They export to Excel to do what the tool should have done. They forgive.
We are determined to flip that. Somehow, it is still radical to be obsessed with users' experience and their outcomes in specialist analytical software. While it's one good win for differentiation, it sometimes requires a trained eye to see where to take cues from commercial consumer software (frictionlessness, rewards, engagement on the first session, simplicity, forgiving interaction mechanics) and where to ignore them to better serve scientists' goals. For example, friction becomes critical when the actions could have devastatingly destructive or expensive impacts; simplification, hiding, prettification, personalization, and opaque AI automation all work against a scientist who depends on readily available, correct and exact information to make a convincing case for something.
The value is inherently baked into the outcomes, so we should take cues from consumer software where it lowers the cost of completing tasks but reject the cues that lower the user's visibility or verification abilities.
One platform, many postures
Ark has features for analysis, optimization, refinement, running potential scenarios, and we have features for live experiment monitoring and fault mitigation. The same scientist might spend an afternoon poring over a finished run, interpreting the results, then check on a live one between meetings the next morning. Analysis and live monitoring call for fundamentally different kinds of attention: one is lean-back, the other is glance-and-act.
Designing for both means deciding, screen by screen and flow by flow, which posture the user is in and what they need in the next ten seconds versus the next ten minutes. Displayed information, alerting format, and hierarchy of importance, among many other considerations, need to reflect this posture. Many products serve one posture or bolt the two together, so designing for both deliberately is an interesting ongoing challenge without much precedent.
Method, held loosely
Use conventions and traditions like human-centered design methodologies, wireframing, or journey mapping when appropriate; shed them readily when they're not useful. A wireframe is a tool for answering a question. If there's no question, skip it. Sometimes the right first artifact is a working prototype, sometimes it's one sentence of UI copy.
Systems, not patches
Given a choice between a quick fix and a flexible pattern, reach for the pattern. Brittle fixes pile up like debt; systems compound. Most of the problems I've solved at Ark weren't one-off screens but recurring shapes; the more care given to the system's foundation (design system primitives, language precedent, error handling, responsiveness behavior, etc.) the more often they stay solved. That said, it is important to understand when a system has reached its logical bounds and extending it is a strain; communicate a need for starting from scratch early so everyone is on board.
In closing
Findings are preliminary, and the error bars are wide! In the next essay I'll dive into the learnings from two real-time optimization digital twin runs at two top-ten pharma partners.
Thanks to the software engineers, ML engineers, scientists and product people who make Ark what it is.