When we decided to rebuild EVgo's mobile app from scratch, we knew we needed to move fast. Our competitors weren't standing still, we wanted to add functionality unique to us beyond what the white-labeled solution offered, and the EV market was accelerating rapidly. We had the internal vision and user research expertise, but we needed execution velocity.
So we did what many product teams do: we brought in an agency to help us brainstorm and implement the design quickly.
It seemed like the perfect solution. Agencies bring fresh perspectives, specialized expertise, and most importantly—dedicated bandwidth. While our small internal team juggled multiple priorities, an agency could focus exclusively on our app design and implementation.
What we didn't fully anticipate was how the financial pressure of that decision would fundamentally shape the design process itself.
The Double-Edged Sword of Agency Partnerships
Don't get me wrong: the agency partnership had amazing benefits. They brought:
- Design expertise that complemented our internal team's capabilities
- Additional hands for rapid prototyping and iteration
- Fresh eyes that questioned assumptions we'd stopped noticing
- Specialized skills in mobile interface design and interaction patterns
But there was a problem that became more apparent with each passing week: the meter was running.
Every sprint planning meeting, every design critique, every round of iteration, every user testing session—each one was adding to a consulting bill that grew larger and more ominous by the day. And everyone knew it.
The Pressure Cooker Effect
Here's what happens when you're working with an agency under tight time and budget constraints:
1. The Temptation to Cut Research Short
We had committed to extensive user research—hundreds of hours of interviews and observation. But as the consulting hours accumulated, there was constant pressure to declare the research "done" and move to execution.
"Do we really need another round of user testing? We've already spent $X on research..."
"Can we just make a decision based on what we know rather than scheduling more interviews?"
The answer should have been "yes, we need more research" in many cases. But the financial pressure created a gravitational pull toward premature closure.
2. Iteration Becomes a Luxury
IDEO's methodology emphasizes iteration: prototype, test, learn, refine, repeat. But iteration is expensive when you're paying agency rates.
Each round of revisions meant:
- More design hours
- More development time
- More project management overhead
- More invoices
We found ourselves having to make hard decisions about when the design was good enough to make sure we moved the team to a production phase.
3. The Paralysis of Consequential Decisions
Big design decisions—navigation paradigms, information architecture, visual design systems—took on outsized weight because we knew changing them later would be expensive.
In an ideal world, you'd make decisions, test them with users, be willing to backtrack if needed, and iterate toward the best solution. But when every hour costs real money, backtracking feels like expensive failure rather than learning.
This created a tension where we felt we had to get the research perfect, so our decisions were properly informed. In a non-agency situation, we'd ship, learn, and iterate at much lower cost.
Ironically, this worry about avodiing mistakes itself was burning consulting hours.
The API Bottleneck Nobody Talks About
But wait—there's more complexity.
While we were racing to design and build the mobile apps with our agency partners, our backend team was simultaneously building out the GraphQL API that the apps would depend on.
This created a three-way coordination challenge:
Agency and internal designers were creating interfaces that assumed certain data would be available.
Mobile developers (some internal, some agency) were building features that required specific API endpoints.
Backend engineers were architecting a GraphQL schema while trying to hit their own deadlines.
None of these streams moved at exactly the same pace. Which meant:
- Designs got created that couldn't be implemented yet because the API didn't support them
- Mock data proliferated throughout the development process, hiding integration issues until much later
- Decisions got deferred because we weren't sure what the API would actually support
- Rework was inevitable when API capabilities didn't match design assumptions
And all of this coordination—the meetings, the alignment sessions, the "can the API do this?" questions—was happening on the agency's clock.
The Psychological Toll
There's a psychological dimension to this that's rarely discussed: when you're working with an agency, every meeting feels fraught.
Internal team members start self-censoring. "Is this question worth asking, or should I figure it out myself to save consulting hours?"
Agency team members feel pressure to show visible progress to justify their billing. This let to tension where the agency wanted forward movement, and we were afraid of making hasty decisions to avoid expensive re-work.
Multiple product managers on a project is challenging. Many engineers would say one PM is too many, and when you have two, coordination, communication, planning all becomes pretty laborious until you work out a clear separation of duties. Even then, I chafed at a situation where I felt like a junior partner because leadership wanted to wring all they could out of the agency while we had them.
Stakeholders scrutinize every deliverable: "We paid $X for this? Is this really what we're getting?"
The trust and psychological safety that's essential for good creative collaboration gets challenged by financial anxiety.
What We'd Do Differently
Looking back on the EVgo app development, here's what I learned about agency partnerships:
1. Separate Strategy from Execution
Agencies can be incredibly valuable for strategic design work—the research synthesis, the design system development, the high-level UX architecture. This is where their expertise shines.
But for execution—the detailed implementation, the inevitable iteration, the ongoing refinement—consider whether you have (or can build) internal capacity. Paying agency rates for implementation means every bug fix and minor adjustment comes with a premium price tag. In our case, it was worth it, as their devs were brilliant and our dev team was more junior at the start.
2. Get API Contracts Defined First
If you're building a mobile app on top of a new backend, get your API contracts defined and agreed upon before you bring in expensive design and development help.
Yes, APIs should be flexible and evolve based on frontend needs. But having a basic schema, understanding what data will be available, and knowing the performance characteristics of key endpoints will prevent massive rework later.
We should have spent more time upfront on API design, even if it delayed the agency engagement slightly.
GraphQL rules for this frenzied development. Being able to design your own queries once the data is exposed clears a lot of the need to coordinate with the backend in more traditional RESTful architectures.
3. Build in Iteration Budget
Don't budget for the "happy path" where every design works perfectly the first time. Explicitly allocate budget for:
- Multiple rounds of user testing
- Design iteration based on feedback
- Technical pivots when implementation reveals issues
- Refinement after initial launch
If you can't afford iteration budget, you can't afford the agency.
4. Define Clear Handoff Points
Agency engagements work best with clear phases:
- Phase 1: Research and strategy (agency-led with internal collaboration)
- Phase 2: Design system and core UX (agency-led)
- Phase 3: Initial implementation (agency-led)
- Phase 4: Refinement and ongoing development (internal team takes over)
Trying to keep the agency engaged indefinitely creates dependency and ever-growing costs. Plan for handoff from day one.
5. Invest in Internal Capability
The best outcome of an agency engagement isn't just the deliverable they create—it's the knowledge transfer to your internal team.
Make sure your internal designers and developers are deeply involved in the process. They should be learning the agency's methods, absorbing their expertise, and building capability to carry the work forward after the engagement ends.
Claudia Petren and Michael Renggli, our internal designers, were essential not just as collaborators but as the institutional memory that persisted after agency contracts ended. Artium, the agency we engaged, was exceptional at making sure we could leave the nest when we left.
The Uncomfortable Truth
Here's the truth that nobody likes to acknowledge: sometimes the pressure of agency billing actually forces necessary discipline.
Without that ticking clock, design projects can meander endlessly. Research becomes procrastination. Iteration becomes perfectionism. Projects that should take six months take eighteen.
The agency pressure forces decisions, creates urgency, and prevents endless deliberation. Sometimes you need that.
But you have to be honest about the trade-offs. Speed and budget pressure will compromise some aspects of quality, user research thoroughness, and iteration depth. You can't have unlimited agency time and also have rigorous human-centered design process.
Finding the Balance
The best agency partnerships I've been involved in strike a balance:
- Clear scope with defined deliverables and success metrics
- Realistic timelines that allow for proper research and iteration
- Budget cushion for the inevitable surprises and pivots
- Strong internal partnership where the agency augments rather than replaces internal capability
- Planned handoff where the internal team takes over for ongoing refinement
During the EVgo app development, we were blessed with a great partner, but even with that stroke of luck, the stresses are inevitable.
The Bottom Line
Agencies can be powerful accelerators for product development. They bring expertise, capacity, and velocity that small internal teams can't match.
But agency partnerships work best when you're ruthlessly clear about the constraints: time, budget, and scope. You can't pretend the financial pressure doesn't exist, because it shapes every decision whether you acknowledge it or not.
If you're going to bring in an agency, go in with eyes open:
- Budget generously for iteration and surprises
- Get your technical foundations solid first
- Define clear handoff points
- Build internal capability alongside agency work
- Accept that some compromises will be necessary
And if you can't afford to do it right—with proper research, iteration, and refinement—consider whether you can afford to do it at all.
The meter is always running. Make sure every hour counts.
This post is part of a series reflecting on lessons learned during the development of EVgo's mobile app, including the organizational and financial challenges of product development at scale.