Lessons from years of turning vendor engagements into long-term wins
Recently, a colleague messaged me to say a project wasn't going well. We had brought in an outside consultant to build our disaster recovery failover plan, and the consultant didn't have the domain knowledge for our systems. The work was drifting.
My colleague's instinct was right. Instead of asking someone else to write our plans, we should have focused on learning the recovery service ourselves.
My reply was simple: never leave it to the vendor. My most successful engagements worked because I learned the platform as if I were going to run it myself, and someone on our side took full ownership. Without that, you get exactly what we were looking at.
That exchange is why I'm writing this post. Most vendor engagements don't fail because the vendor is bad. They fail because the organization hands over the problem and walks away.
Companies bring in vendors and contractors because they lack a skill. That part is reasonable. The trouble starts when the engagement is treated as insurance: if it goes wrong, it was the vendor's fault. That mindset is the root of most failures I have seen.
I'm a database and infrastructure engineer. Over the years I've led engagements with Oracle, Splunk, AppDynamics, AWS, and a managed database support provider. Every one of them paid off, some in seven-figure savings and some in ways most organizations never measure: faster incident resolution, reusable know-how, and teams that could stand on their own once the vendor left.
This post covers what made those engagements work, the stories behind them, and the mistakes I'd tell anyone to avoid.
Think like a homeowner hiring a contractor
If you hired a contractor to finish your basement, build a deck, or redo your kitchen, you wouldn't just sign and disappear. You'd learn what needs to be there, short of building it yourself.
That knowledge lets you challenge the contractor, ask questions they have to answer, and track real progress. It keeps you from overpaying, from getting cheaper parts than you paid for, and from paying for parts the project never needed.
I apply the same philosophy to every vendor engagement. I may be completely new to the technology on day one. But to make the project succeed, I have to learn it well enough to support it myself. The question I keep asking from start to finish is simple: how will my organization run this when the vendor is gone?
Story 1: Oracle GoldenGate — when the vendor becomes your teacher
I've run GoldenGate projects since my time at Verizon. One of the most valuable engagements of my career was working directly with Oracle to build bidirectional GoldenGate replication.
Bidirectional replication is unforgiving. Conflict handling, loop prevention, and trail management all have to be right, or data drifts quietly until someone notices. I didn't treat Oracle's engineers as people doing the work for me. I treated them as teachers, and I asked questions until I understood why every setting was there.
That knowledge became the real deliverable. It carried my career forward, and over the following years it saved the company seven figures, because we could design, run, and troubleshoot replication ourselves instead of paying for outside help each time.
Lesson: build learning into the engagement. The license or the statement of work ends; what your team learned keeps paying.
Story 2: Splunk — make the vendor prove your worst log
Vendor presentations are usually polished, and mostly accurate. But they show the clean cases. Every organization grows its own edge cases over the years, and a demo never covers those.
In Splunk, sourcetypes are where the parsing logic lives: how a raw log line is broken into fields you can search, alert on, and graph. During the proof of concept, I didn't ask Splunk to parse a clean, well-formatted log. I picked the worst log in the company, the one nobody wanted to touch, and asked them to prove the platform could handle it.
Their engineers wrote the sourcetype configuration to parse it during the POC. I studied how they built it, reverse-engineered the approach, and reused it to onboard logs for several other projects afterward.
That work could easily have turned into a paid professional services engagement. It didn't, because I learned how the code worked while the vendor's experts were in the room.
Lesson: design the POC around your hardest case, not the vendor's easiest one. Then learn from how they solve it.
Story 3: AppDynamics — let your internal customers certify the POC
With AppDynamics, I leaned on the vendor's know-how to write custom extensions that monitored what the product didn't cover out of the box. Getting close to their architects mattered here. That relationship is what makes or breaks an engagement like this.
But the bigger lesson was about adoption. The product teams were part of the decision and the POC from the start. They weren't handed a tool someone else had picked. They tested it on their own applications and APIs, and they liked what they saw.
So the rollout was fast. Teams adopted it without being pushed, and started thinking about how to use it in their own development cycles. The same approach worked for our Splunk rollout.
The payoff showed up during incidents. Problems that used to take hours of cross-team digging got resolved in a fraction of the time, often by Tier 1 support engineers who could now see API and database performance issues themselves.
Lesson: if one team certifies a POC and pushes the result onto everyone else, you won't get adoption. Make your internal customers partners in the evaluation.
Story 4: AWS — learn how the provider's experts think
A cloud provider is a different kind of vendor. You aren't buying a project; you're buying services, and the expertise behind them is easy to leave on the table if all you do is open support tickets.
When we worked with AWS on Database Migration Service (DMS) and AWS Backup, I treated their specialists as a source of knowledge, not just a help desk. I wanted to understand how they think about these services: where they fit, where they don't, and what trips up other customers at scale.
That understanding shaped how we designed migrations and backup strategy, instead of us discovering the limits the hard way in production.
Lesson: your cloud provider's architects have seen thousands of customers. Ask them what goes wrong, not just how to configure things.
Story 5: A managed DBA team — set the rules early, let them evolve
Sometimes you bring in a vendor because your internal bench is thin. We partnered with a managed database support provider whose DBA team covered work we didn't have the internal depth to handle alone.
At the start, I set up the procedures and rules of engagement: how work comes in, how it's escalated, who owns what, and what "done" means. It wasn't glamorous work.
But that foundation held. The support ran seamlessly for years. The rules evolved as both sides gained experience, but we never had to tear them down and start over.
Lesson: with a managed service, the first few weeks of process design decide how the next several years go.
The playbook: what to do
- Write requirements and expectations down up front. Vague goals give the vendor room to declare victory on their terms.
- Ask internal customers what success looks like to them. They become your partners in the result, not critics of it.
- Make the vendor prove it on your platform. A thorough POC on your complex scenarios is worth more than any slide deck.
- Get close to the vendor's architect. That relationship decides whether hard problems get solved or escalated forever.
- Learn what you'll be supporting. Even if the technology is new to you, learn it well enough to run it alone.
- Build learning into the engagement. Knowledge transfer is a deliverable, not a favor.
- Use AI for research. Before the engagement, research what success metrics other organizations use for the same kind of platform. It sharpens your requirements and your questions.
And remember: the vendor wants your project to succeed too. A failed engagement doesn't help their reference list.
What not to do
- Don't trust the vendor to do the whole job. That's the most reliable recipe for failure I know. Work with them closely, every step.
- Don't treat the engagement as cover. "We hired experts, so it's on them" protects no one when the system breaks after the vendor leaves.
- Don't let one team certify the tool for everyone. Adoption you force rarely becomes adoption you keep.
- Don't skip the hard cases in the POC. If the vendor never touched your messiest system, you haven't tested anything.
- Don't buy what you can't support. If no one internally can run the product, you'll pay for it for years and get little back.
- Don't let internal friction go unaddressed. Some engineers would rather build it themselves and see the vendor as a competitor. They focus on why the vendor is failing instead of sharing the context that would make the solution better.
A note for leaders
The engineer running a vendor engagement carries a lot. These projects are usually meant to solve a real problem or prepare the organization for the future, and that responsibility sits on their shoulders.
Three things help them succeed:
- Give them time. Don't assume the vendor is doing the work and the internal owner needs only a few hours a week. If you want the project done right, budget real time for it.
- Set expectations with the team. Make it clear why the vendor is there and what the internal owner is accountable for. Clear up concerns early, before they turn into resistance.
- Give credit where it's earned. It's common for people to assume "the vendor did it" and overlook the internal engineer who made it work. Recognize the people who make these partnerships succeed.
How to measure success
Some wins show up on a budget line, like the seven-figure savings from owning GoldenGate in-house. Many don't, and organizations often have no KPI for them.
The measure I care most about is this: does the platform enable other people? When a Tier 1 support engineer can resolve an API or database performance issue in a fraction of the time it used to take, without escalating, the engagement worked. When teams adopt a tool into their development cycles on their own, it worked. When your team can run the platform after the vendor has gone, it worked.
Leaders should look for these outcomes and recognize the people who deliver them.
Closing thought
Vendor engagements aren't the most exciting work for strong engineers. There's process to design, requirements to chase, and a lot of time spent learning someone else's product.
But this is foundation work. Done well, it shapes how an organization operates for years. Bring the vendor in for their expertise, and keep the ownership for yourself.
If you've led vendor engagements of your own, I'd like to hear what worked and what didn't. Share your experience in the comments.







Top comments (0)