Product Manager · Costa Rica

I design decisions before I design products.

Most product work isn't deciding what to build. It's deciding what problem is actually worth solving, who gets a vote, and what trade-offs everyone is willing to live with. Turns out ambiguity is a lot more fun than it sounds.

I'm Gabo. I've spent most of my professional time helping teams make decisions before they build products. Recently that has meant navigating the messy world of AI tooling, where the hard question isn't "which platform wins?" but "which one should do this job?" Outside of work I'm usually cooking, mixing a cocktail I'll insist is "almost right," watching football, or getting outvoted three to one by my schnauzers.

9
Years in PM / PO roles
20+
Products shipped for clients
4
Startup discoveries led
Confident enough to simplify. Curious enough to wonder if I simplified the wrong thing.

If you're looking for polished success stories, this probably isn't that. Product work is messy. Mine certainly has been.

I'm more interested in the messy decisions that happened before anything shipped, because that's where product management actually earns its salary. And, of course, making sure the devs are delivering as expected.

A good product conversation should have enough structure to reach a decision, but enough room for someone to prove everyone else wrong. One thing I'm proud of is making quieter voices part of the conversation. I'd rather ask an uncomfortable question early than write a polished roadmap around the wrong assumption.

Most of what follows isn't about features I shipped. It's about the calls I made before shipping was even on the table, including the ones that worked and the ones that didn't. Thankfully there have been more of the first than the second.

Client work

Where most of the last five years went

Five years, dozens of products, plenty of trade-offs. I don't walk through features. I walk through the decisions that made those features inevitable.

Imaginex
~2 years · sole PM
Sophicare
What were we actually optimizing for? Missed visits are the real failure in home care. Build everything around preventing them.

We partnered with CAB, a caregiving company with more than 15 years of experience, to build Sophicare from the ground up. I was the only Product Manager on a cross-functional team of around 20 people over nearly two years.

Early on, we learned that calendars weren't the bottleneck. A visit only happens if the right caregiver can realistically make it, which meant matching skills, availability, proximity, and care requirements before thinking about schedules. Once we made that decision, the rest of the product became much clearer: care plans became the source of truth, matching drove assignments, and scheduling became the consequence instead of the starting point. Mobile task tracking, clock-in/out, and reporting mattered, but only because they supported the real objective, making sure clients weren't left waiting for care that never arrived.

HealthcareMatching logicWeb + mobileDiscovery to prod
Imaginex
~1 year
Gilly
What were we actually optimizing for? Getting a permit approved wasn't hard because of the paperwork. It was hard because every missing detail meant another round of back-and-forth with the Watershed District.

Gilly digitized the permitting process for construction projects across Montana's watersheds. I worked with a team of around eight engineers and UI/UX to redesign both the applicant and reviewer experience. The goal wasn't simply to replace PDFs with forms. It was to cut the endless back-and-forth between applicants and the Watershed District, where every missing location, unclear boundary, or incomplete submission meant another review cycle and more waiting.

On the admin side, we integrated Mapbox so reviewers could immediately understand where construction was proposed and see nearby permits without piecing information together by hand. The map wasn't part of the applicant experience, it was a decision-making tool for reviewers. Geographic context upfront meant fewer clarifications, fewer emails, and fewer rounds of bureaucracy before a permit could move forward.

GIS / MapboxGov / environmentalWorkflow design
Imaginex
Product
SlowTalk
What were we actually optimizing for? The loudest voice shouldn't be the one that shapes the conversation.

SlowTalk wasn't built to make meetings faster. It was built to make them fairer. Instead of open discussion where a few participants naturally dominate, every person gets a dedicated speaking window while a facilitator quietly manages the flow. The platform enforces turn-taking, making listening just as important as speaking.

I worked on shaping the product around that constraint. Timers, moderation controls, and structured speaking turns weren't limitations, they were the mechanism that created better conversations. By removing the competition for airtime, the platform surfaced perspectives that usually disappear in traditional video calls.

Real-timeConversation design0 to 1

Discovery workshops aren't a copy-paste

The process might look familiar. The discovery never does. Every discovery I've led looked different because every business had a different problem to solve. The framework stays familiar: understand the business, talk to the right people, map the user journey, and draw a defensible line between the MVP and what can wait. The questions never stay the same. A phishing platform, a home-care product, and a conversation tool don't carry the same risks, don't serve the same users, and shouldn't end up with the same priorities just because someone has a favorite framework. The value of discovery isn't following the same process every time. It's knowing when the process needs to adapt to the business in front of you.

Cybersecurity · phishing campaigns Sophicare · home care +2 platforms, different shape

The full range

Not every product starts with a blank page. I've joined products mid-flight, led three-week migration sprints, built new platforms from scratch, and taken products all the way through retirement. Different stages demand different decisions, but the responsibility stays the same: leave the product in a better place than you found it.

Things I've built

And the ones that are mine

Outside client work, these are the products I've owned end to end. Building your own product changes your relationship with every decision. There's no client to hide behind, no roadmap handed to you, and no one else to blame when something doesn't work.

2026
Live
Leo & Vera
The call: if every sale depends on answering a DM, I haven't built a business, I built myself another job.

Leo & Vera is a natural hair care brand for kids that I co-founded with a designer partner. Before thinking about Instagram or marketing, we built the operation: an automated e-commerce experience, payment processing, inventory management, shipping through Correos de Costa Rica, and customer communication. The goal wasn't automation for its own sake. It was making sure the business could scale without requiring someone behind a phone every time an order came in.

Leo & Vera shampoo and conditioner bottles, four SKUs, in a bathroom setting
0 to 1E-commerceBrand + ops
2025
Live
FisiaPrep
The call: the biggest constraint wasn't knowledge. It was time.

I built FisiaPrep for my partner while she prepared for her physiatry specialty exam. Residency doesn't leave uninterrupted evenings to study, it leaves short breaks, commutes, and the occasional quiet moment between shifts. Instead of building another question bank, I designed the product around those moments: spaced repetition by topic, confidence-based review, and a two-voice audio mode for studying during commutes. A driving-safe mode made it possible to review without looking at the screen. She later scored over 90 on the exam, but the part I'm proudest of isn't the grade. It's that the product fit her life instead of asking her to reorganize it.

FisiaPrep dashboard: study topics for a physiatry specialty exam with per-topic mastery scores
Spaced repetitionVoice pipelineSolo build
2020–2026
Closed
Loggicare
The decision that quietly aged badly: a model that depended on me personally doing weekend deliveries.

I co-founded Loggicare and ran it for six years alongside a full-time job. For a long time, the model worked. Orders came in, weekends became delivery days, and the business kept growing. What closed it wasn't one bad decision. It was a series of good decisions that slowly stopped fitting reality. Demand softened, my time became the bottleneck, and the business had never been designed to operate without me. Closing it taught me something I still carry into every product I build: if the founder is part of the infrastructure, the business doesn't really scale.

E-commerceSix years solo-runWhat I fixed next time
Before this

Where the habit started

Before I ever had "Product Manager" in my title, I was already learning how to define success before building anything. The title changed. The habit didn't.

2017 – 2020
Product Owner
Kuehne+Nagel
The call: automation without a measurable outcome is just expensive software.
I built a process inventory from scratch for a portfolio of robotic process automation initiatives across multiple countries. Before development started, every automation had to justify itself with a measurable ROI in FTE hours saved. Defining that success criteria upfront became part of the product, not an afterthought once the automation shipped.
2016 – 2017
Continuous Improvement Coordinator
Philip Morris International
The call: a good idea doesn't matter if the organization doesn't have room for it.
I led Lean Six Sigma initiatives across cross-functional teams, mostly within Finance. The projects were solid, but many struggled to gain traction for a simple reason: the people whose support I needed were already overwhelmed by their day-to-day. That experience changed how I think about product work. A solution isn't successful because it's right. It's successful when people have the capacity, incentives, and context to adopt it.
2020

COVID cost me my job the same year everything else got harder. For a while, my days looked strange. I'd spend the early morning making empanadas, grab a few hours of sleep, then head out to deliver them. At the same time, I started Loggicare. Neither was some grand entrepreneurial plan. One helped pay the bills. The other was a bet that I could build something that lasted longer than the next month.

I don't see that period as a motivational story. If anything, it taught me how easy it is to build a business around your own effort without realizing you've become part of the infrastructure. That's why the next company started with automation, not marketing.

How I think

Not rules. Just patterns I've noticed about myself.

Things I've noticed about myself

I ask a lot of questions.

Sometimes enough that people think I'm disagreeing. Most of the time I'm just trying to understand the problem well enough that the solution becomes obvious.

I get excited embarrassingly fast.

AI. Haircare. Watershed permits. Children's shampoo. Doesn't really matter. If I find the problem interesting, I'll disappear into it for a while.

I care a lot about the team wanting to build it.

People rarely do great work because someone asked them to. They do it because they believe the problem is worth solving. That's the environment I try to create.

I usually realize what I think halfway through saying it.

It's a weird way to process ideas, but it's served me well. Some of my favorite product decisions came from conversations where nobody, including me, knew the answer walking into the room.

Things I've learned mostly by getting them wrong first

AI didn't replace thinking. It exposed it.

AI can write a presentation in five minutes. That's exactly why knowing what you're trying to say matters more than ever. The hard part was never prompting, it's having a clear idea before you start typing. I treat AI like the friend I'm gossiping with while trying to solve a problem. Most of the time, it does a pretty good job.

Developers aren't resources. They're stakeholders.

Some of the best products I've worked on happened because the engineering team believed in what we were building, not because someone asked them to. People do better work when they actually care.

I learn by building.

Reading isn't really my thing. Building is when everything clicks. Most of what I know about AI, GitHub, Vercel, automation, pipelines, even product management, came from making things that probably weren't going to work the first time. If something catches my attention, there's a good chance it'll become a weekend project.

Not all feedback deserves the same weight.

I love criticism. I don't love cynicism (unless we're talking about comedy). Some people challenge ideas because they want the work to improve. Others just enjoy being the smartest person in the room. Learning to tell the difference has been as important as learning to accept feedback.

Say the uncomfortable thing early.

People can usually handle difficult conversations. What they don't handle well is surprises. Whether it's a slipping deadline, a product that isn't working, or an assumption that turned out to be wrong, I'd rather say it early than spend weeks pretending it'll fix itself.

People don't build great products because they're told to.

They build them because they believe they're worth building. One of the things I'm proudest of isn't a launch or a metric. It's when someone tells me, months later, "that was one of my favorite projects to work on." I want people on my team because they believe in what we're building, not because they have to be there. Turns out that's a much stronger reason to row in the same direction.

Principles

What I actually believe about this work

”

The PM role got wider, and pretending it didn't is the mistake

In one quarter the job can mean leading a 20-person build, owning a product from discovery to production, running a vendor evaluation, writing the system prompt, and translating all of it for executives. That's not scope creep, it's what the role actually is now. The title didn't shrink, the job description everyone keeps copying just hasn't caught up.

”

Progress over perfection, but the criteria don't get to be vague

Moving fast is fine. Moving fast without a clear definition of done is just deferred rework.

”

Bad news should sound the same as good news

A schedule slip, an underperforming vendor, a channel that isn't converting: none of it needs spin, and none of it needs alarm. It just needs to be said plainly and early.

”

A pilot exists to validate cheaply before anyone commits expensively

The point of a pilot or an MVP isn't to ship something small, it's to find out whether the expensive version is even worth building, while the cost of being wrong is still low. Kill it early or scale it with evidence. Either one beats guessing.

Ask me anything

Skip the resume, ask a real question

A small model with just enough context about my work to answer honestly, including the parts that don't flatter me.

Ask me about the AI pilot, Loggicare, or anything else here. I'll try to answer the way I actually would.
Toolbox

These aren't superpowers. They're just the things I keep reaching for.

I talk to people.

  • Product Discovery
  • Stakeholder Interviews
  • Workshops
  • Facilitation

I bring structure to messy problems.

  • Story Mapping
  • Prioritization
  • Roadmapping
  • MVP Definition

I make ideas real.

  • AI Prototyping
  • AI Workflows
  • Prompt Design
  • GitHub
  • Miro
  • Canva

I make sense of data.

  • Excel
  • SQL
  • Power BI
  • Tableau
Get in touch

If you've read this far, you've probably noticed something.

I tend to enjoy problems that don't have obvious answers yet. If you've got one, let's talk.

Case study · Agentic AI Pilot

Evaluating agentic AI for enterprise adoption

A 90-day pilot to determine how and where agentic AI could create measurable business value across a global consumer brand. Rather than selecting a single platform, the outcome was a routing model, governance framework, and phased adoption strategy that gave different teams a clear path forward.

RoleProduct Manager, leading product strategy and evaluation
Duration90 days + 1 week
Scope5 platforms · ~30 use cases · 6 business functions
OutcomeRouting model adopted for Phase 2

The situation

Agentic AI had crossed from novelty into something leadership could no longer ignore. IT leadership and the CISO recognized that teams would inevitably start experimenting with AI. The real question wasn't whether that would happen. It was whether it would happen deliberately, or by accident, one department at a time, with no shared governance and no consistent security posture.

Five platforms emerged as serious candidates, ranging from Microsoft-native builders to external-connector platforms and reasoning-first models. There wasn't a consistent way to compare them across teams as different as Legal, Finance, HR, and Audit.

Waiting for hard numbers wasn't really an option. By the time those existed, different teams would already be making different decisions with different tools. The case for action was as much about governance and risk as it was about technology.

The original question was simple: which platform should we buy? The better answer turned out to be: it depends on what you're trying to do.

The real outcome wasn't choosing a winner. It was creating a repeatable way to choose the right platform for each use case.

The original assumption

When the pilot started, the assumption was simple: evaluate the leading platforms thoroughly enough, and one of them would emerge as the company standard. That isn't what happened.

As we worked through more use cases, a different pattern emerged. The deciding factor wasn't the department requesting the solution. It was what the agent needed to connect to. The recommendation shifted from selecting a single platform to creating a routing model: Microsoft-native work stayed in Microsoft's ecosystem, use cases that depended on external systems followed a different path, and tasks that didn't require integrations could use standalone reasoning models.

What does the task need to connect to? Microsoft tools Non-Microsoft tools No connector needed Microsoft-native builder Deep 365 / Teams reach External-connector builder Non-Microsoft systems Reasoning model (no connector) Self-contained tasks One builder discontinued mid-pilot after underperforming on build and stability checks Routed by technical constraint, not department preference
Fig. 1 — Platform routing logic.

The more we tested this approach, the more confident we became in it. By Phase 2, the routing model evolved into the idea of an MCP Gateway: a layer that could consistently direct requests to the right platform while giving engineering teams a separate path for native development.

The biggest takeaway wasn't that one platform won. It was that there shouldn't be a winner.

What I led

As the Product Manager, I helped lead the pilot from evaluation through recommendation. I designed the evaluation framework, facilitated workshops to define nearly 30 use cases across six business functions, and worked with Legal, Finance, HR, Audit, and IT to understand what each team was trying to accomplish.

Throughout the pilot, I shared weekly updates with leadership, ran enablement sessions for citizen developers, managed the issue tracker, and turned technical findings into recommendations people could actually make decisions with. The goal wasn't just to compare platforms. It was to help the organization adopt AI deliberately instead of one team at a time.

CATEGORY AVERAGE, WEIGHTED Build experience 35% Connectors & integrations 20% Observability & debugging 15% Cost & licensing 15% Security, privacy & compliance 7% Accuracy, governance, scalability 4+2+2% Weights were locked before any platform was scored. Build experience alone outweighed security, governance, and scalability combined.
Fig. 2 — Evaluation rubric and category weighting.

The weighting wasn't an accident. It was defined before any platform was evaluated. Build experience carried the most weight because that's where we expected most of the work to happen. Security, governance, and scalability still mattered, but they weren't the primary differentiators for the use cases we were evaluating.

One interesting outcome was that the highest-ranked platform also received the lowest scores for governance and security. That wasn't a flaw in the framework. It showed exactly what weighted scorecards are designed to do. They don't identify the platform that's best at everything. They identify the platform that's best for the priorities you've agreed on before the scoring begins.

How the 90 days actually went

Kickoff & mandate
Pilot launched with a 90-day mandate. Three pillars established: governance, enablement, and a central AI marketplace.
Use case & platform identification
Nearly 30 use cases identified across six business functions. Five platforms selected. Evaluation rubric v1 created.
Build & test
Technical and security evaluations run in parallel across platforms. Governance framework drafted. More than 60 enablement sessions delivered for citizen developers across departments. A one-week delay absorbed by the project buffer.
Mid-pilot correction
One builder underperformed on stability and structural gaps, and was removed mid-pilot rather than carried through to the end. Evaluation rubric refined to v4.
Scoring & synthesis
Final rubric scores locked. Department interviews completed to gather feedback from AI champions. Adoption readiness mapped across business functions.
Closeout & reporting
Final report, platform routing model, and phased adoption plan delivered. Weekly executive updates provided throughout the pilot, concluding with an executive summary for the project sponsor.

Adoption readiness, by profile

This wasn't part of the original scope. As the pilot progressed, it became clear that recommending platforms wasn't enough. If the organization moved into a second phase, different departments would need different levels of support. Measuring adoption readiness gave us a practical way to plan that.

Readiness turned out to correlate much more with process maturity than with excitement about AI.

Early adopters High process rigor, clear use cases Developing Willing, still defining use cases Early stage Interested, no active pilot yet Not continuing One function, low fit for this use case
Fig. 3 — Illustrative readiness tiers. Eight of nine business functions reached active-adopter status.

What we learned during the crawl phase

This was the crawl in a crawl, walk, run adoption path. The goal wasn't to prove every platform was ready. It was to surface the constraints early enough to make better decisions before scaling.

One platform wasn't ready for enterprise use

One builder consistently struggled with core capabilities. Native file generation wasn't available inside workflows, enterprise integrations proved unreliable, and stability issues interrupted live demos. Removing it from the evaluation before the pilot ended was the right decision.

Champion engagement mattered more than expected

Not every platform was evaluated with the same level of depth. Some citizen developers explored their tools extensively, while others barely moved beyond the basics. That meant part of the evaluation reflected adoption and familiarity, not just platform capability. That became an important input for Phase 2. If we wanted a fair comparison, we first needed a more consistent enablement approach.

Even the highest-ranked platform had trade-offs

The top-ranked platform wasn't perfect. We saw inconsistent formatting across identical prompts, and at least one platform struggled when large amounts of context were pasted into a conversation. Calling those limitations out mattered. The goal wasn't to defend a winner. It was to make a recommendation leadership could trust.

The issue log told its own story

Most high-severity issues were escalated directly to the vendors rather than solved internally, which was the right decision. Many of them traced back to the builder that was ultimately removed from the pilot, reinforcing the decision to stop investing in that path.

What Phase 2 builds on

The pilot answered the biggest strategic question: there wasn't a single platform that fit every use case. That allowed Phase 2 to shift its focus from evaluation to adoption.

One of the clearest process improvements was standardizing how citizen developers participated in the evaluation. During the pilot, some champions explored their platforms in depth, while others had much less time available. That made part of the comparison reflect individual engagement, not just platform capability.

For Phase 2, we recommended defining a minimum level of participation before scoring began, whether measured in hours, sessions, or completed exercises. It's a small process change, but it makes the evaluation far more consistent from the start.

What this taught me

The most valuable output of the pilot wasn't choosing a winning platform. It was creating a decision framework that could outlast the platforms themselves. Leadership started by asking which tool to buy. The more durable answer was a routing model that made the decision based on the problem being solved, not the tool that happened to be most popular at the time.

The other lesson had very little to do with AI. Most business teams weren't looking for an explanation of large language models. They wanted someone who could help them understand where AI fit into their work, where it didn't, and how to move forward without creating unnecessary risk.

Looking back, that's what I'm most proud of. Helping people with very different perspectives work toward the same decision, even when none of us had all the answers at the start.