Gallery
main
Straddle 101 - Internal
Share
Explore
Big ideas '25

icon picker
Engineering @ Straddle

If your rocket points in the wrong direction, it’ll miss the target, no matter how fast it goes.
Products—and the teams behind them—work the same way. A “10x engineer” might have incredible technical skill, but if they focus on the wrong priorities, the product doesn’t magically become 10x more successful.
At our organization, we rely on engineers to make product decisions. They help plan roadmaps, set goals, and carry these through to completion. More than at many companies, our engineers are responsible for pointing us in the right direction, which is why we look for specific traits beyond technical brilliance.

1. Always Prototyping and Experimenting

You can plan and polish a feature endlessly, but we prefer to ship early and iterate. We value engineers who are comfortable with:
Building functional MVPs and proofs of concept
Shipping before the feature might look “ready” to others
From a product perspective, this doesn't mean skimping on testing or reliability
Gathering user feedback and quickly fixing issues
Pivoting or eliminating features that aren’t working out
To do all this, an engineer needs enough versatility to take a product from zero to usable—knowledge of infrastructure, scalability, usability, and design. We don’t rely heavily on product managers or dedicated designers by default, so engineers must have these skills to stay autonomous.
Example: A theoretical engineer single-handedly launched an early-stage analytics feature. The first release was extremely simple—just enough to prove the concept. Over time, they refined the visuals, added additional metrics like scroll depth, tackled user feedback, optimized query performance, tested sampling approaches, and more. Getting it to a solid beta required skills across the entire stack.

2. Comfortable Writing

We work in a remote and asynchronous environment, so most of our communication is in written form. This means our engineers regularly:
Write issues describing new features before building them
Provide documentation and updates after features launch
Craft pull request descriptions and respond to review comments
Create RFCs (Requests for Comments) for big, cross-team decisions
Maintain process docs in our shared handbook
Writing is critical because it reflects clear thinking, reduces unnecessary meetings, and keeps us moving quickly. In some cases, a single RFC can run to thousands of words with equally in-depth discussion in the comments. This level of detail is a necessity for complex cross-team initiatives.

3. A Genuine Love for Building

Broadly, there are two types of engineers:
Those who do it because it pays the bills.
Those who do it because they love the craft.
We see nothing wrong with the first, but we specifically seek those in the second group—people who are motivated by the work and our mission. These engineers are more likely to:
Take initiative without constant direction
Drive new ideas from concept to final feature
Stay excited about big opportunities and new technologies
Because our engineers help set product direction, those who genuinely love to build tend to push both speed and quality to the next level.

4. Customer Obsessed

To uncover real user problems—and the solutions they truly value—our product engineers do more than write code. They:
Talk directly to users, conduct interviews, or recruit testers
Gather feedback for new features and respond to support requests
Own incidents or issues and fix them fast
Example: Suppose an engineer is working on an invoicing feature. Their goal might not be “build X features”; it might be “acquire and retain five reference customers for this new product.” To get there, they talk to potential users, learn what connectors and integrations matter most, and then shape the product to those needs. They keep iterating until the solution really works for those customers.
The opposite of this mindset is being attached to a personal idea of what’s “right”—spending weeks polishing the “perfect” version rather than launching quickly to see if it truly helps customers. Focusing on real user needs ensures we build products people actually want, not just what we think they need.

5. Understands the Broader Context

Our teams will have autonomy to define their own roadmaps and goals as long as it aligns how Straddle adds value. That means each team member must use all available data to make the best decision possible. This includes:
Evaluating user feedback, usage metrics, and industry benchmarks
Analyzing competitor offerings—from features to pricing
Deciding on the right success metrics for a new feature
Accounting for infrastructure requirements, scalability, and performance
For example, if a team is building an embedded checkout feature, they might research existing tools, competitor capabilities, and user preferences before settling on the specifics. They also define the data structure, client lifecycle, and compatibility with key libraries to ensure future scalability.
By seeing the bigger picture, engineers avoid building something that might work today but won’t hold up as the product or user base grows.

6. Easy to Work With

We know our journey isn’t always going to be smooth, so we want people who keep things positive and collaborative. This often correlates with experience, but not always. We look for folks who avoid self-promotion, treat colleagues with respect, and communicate proactively.
Example: The best kind of communication is often a direct pull request. In some companies, the default is to add tasks to someone else’s queue. We should prefer a culture where you try to solve it yourself and open a PR—even if it’s incomplete—because it’s easier for others to review and tweak an existing draft than to start from nothing.
Difficult personalities create tension and slow everything down, which is especially harmful in a startup environment that thrives on rapid iteration and open feedback.

Why We Value These Traits

Yes, prioritizing these traits can limit the pool of engineers you can hire, especially the mythical “10x” ones who only want to code. But here’s the trade-off: you end up with a more effective, engaged team that can move faster and achieve more with fewer people.
Among other benefits, this approach lets us:
Optimize for speed: Small, autonomous teams can ship quickly without layers of approval.
Minimize hierarchy: We have just a small executive tier, and “manager” roles are part-time hats IC people might wear rather than a permanent title.
Keep everyone focused: We trust each other to get things done, relying on feedback instead of rigid processes.
Stay lean while growing: We’ve seen how a small increase in headcount can still lead to significant product leaps when you have the right folks on board.
We believe that talent compounds. It’s worth the extra effort to find engineers with not just top-notch technical abilities but also the product, communication, and collaboration skills outlined here. Our culture—and our growth—prove it’s a winning formula.

Share
 
Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.