How In-House SEOs Collaborate with Developers to Get Technical SEO Requests Implemented.

This is Part 4 of our In-House Insights series, where we dive into the messy, real-world challenges in-house SEO teams deal with every day. This time, we’re tackling one of the most critical (and often most frustrating) parts of the job; working with developers to get SEO changes implemented.

---

Behind every successful technical SEO initiative is a developer who made it happen.

That’s the hard truth most SEO professionals learn quickly; often the hard way.

You can run a best-in-class audit, uncover critical technical SEO issues, and craft a strategy built for scalable growth. But none of that matters until your recommendations are implemented.

And for that to happen, it means one thing… that the relationship between SEO and developers isn’t just important, it’s mission-critical.

In many in-house teams, however, this relationship is fragile, misaligned, or altogether non-existent.

SEOs often feel stuck in a cycle of writing tickets that get ignored or deprioritised, while developers are inundated with vague requests that don’t feel aligned to business goals or user needs. It’s no surprise that friction forms, but it’s entirely possible to fix.

This guide exists to help you do just that.

Here, we’re going beyond generic advice to unpack how some of the most experienced in-house SEOs and technical SEO specialists are making implementation happen inside their organisations. Their insights are raw, practical, and rooted in years of hard-won experience, not just theory.

You’ll hear from:

They’ll share what works, what doesn’t, and how to transform your SEO-dev relationship from a bottleneck into one of your biggest levers for organic growth.

tl;dr: How In-House SEOs Collaborate with Developers to Get Technical SEO Requests Implemented

Technical SEO wins don’t come from audits; they come from implementation. And that only happens when SEOs and developers work as true collaborators, not siloed teams.

This guide brings together hard-won lessons from four in-house SEO pros who’ve made dev collaboration a core part of their success. It’s packed with practical advice on turning friction into trust, and ignored tickets into shipped fixes.

If your biggest SEO blocker is developer time, this guide is your blueprint for breaking through.

Key takeaways:

• Frame SEO tasks around business value, not SEO jargon; devs and product teams care about outcomes, not optimisation checklists.
  
• Clarity beats urgency. Well-written, developer-friendly tickets with clear value, scope, and outcomes get picked up faster.
  
• Start early, not late. SEO needs to be considered before sprint planning and design, not after build is complete.
  
• Trust is earned outside the ticket queue. Build credibility through consistent communication, empathy, and shared wins.
  
• Pushback isn’t rejection. Use it as a chance to understand constraints, adjust your ask, or reframe the business case.
  
• Collaboration beats escalation. Escalate only when necessary, and with context, not frustration.
  
• Treat developer time as a business resource. You’re not making a request, you’re pitching an investment in growth.

The most impactful SEOs don’t just make recommendations. They make things happen.

Where Misalignment Happens & Why

To fix the SEO-dev relationship, you first need to understand where, and why, it breaks down.

Ask almost any in-house SEO where friction begins, and the answers tend to sound familiar

• delays
• deprioritised tickets
• pushback on recommendations

But these aren’t the root causes. They’re symptoms.

And they usually trace back to something much more fundamental; a breakdown in communication, process, or a lack of shared priorities.

In fact, one of the most common sources of tension is a lack of mutual understanding.

SEOs and developers often operate in completely different worlds, with different languages, priorities, and pressures, and little appreciation for what the other side actually does.

Without a shared understanding, assumptions take hold.

Developers may see SEO as just another “marketing” request, divorced from the product itself.

SEOs may underestimate how much work, risk, or technical debt a seemingly simple change can create.

As Hannah puts it:

Bridging that gap requires more than tickets and task lists. It means giving developers context, not just tasks.

Don’t just explain what needs doing, explain why it matters and what happens if it doesn’t get done. The goal is shared visibility, not one-way requests.

But this kind of misalignment doesn’t just happen mid-sprint. Often, it starts far earlier.

Luke Monaghan, Global Head of SEO at lululemon, has seen the same pattern: misalignment begins at the start. His advice is to begin every SEO-dev interaction with clarity, not just about what’s wrong, but what impact it’s having.

That early clarity is crucial.

If developers don’t understand the value of the change at the outset, you’ll run into resistance later; when the cost of change is higher and the appetite for rework is lower.

Of course, there’s also the broader issue of prioritisation. It doesn’t matter how well a request is written if SEO isn’t seen as a priority by the business, or by the dev team.

At Priory Group, organic search drives more than 80% of total traffic, for example; a fact that Stefan makes sure is understood across the company, including within the development team.

When SEO is recognised as a key revenue driver, not just a support function, it earns its place in the development roadmap. Alignment stops being a negotiation and starts becoming part of the culture.

Because ultimately, misalignment isn’t about resistance. It’s about missed opportunities: missed chances to build understanding, to define shared goals early, and to communicate clearly at every step.

For in-house SEOs, this means stepping out of the reactive mindset.

You have to make SEO part of the process from the start, framing your requests around business impact, speaking the same language as your developers, and educating stakeholders along the way.

That’s the foundation of collaboration.

The next step? Figuring out how to make developers care about the SEO work you're asking them to prioritise, even when their backlog is already full.

How to Make Developers Care About SEO

One of the hardest realities for in-house SEOs is that your recommendations are never evaluated in a vacuum.

You’re not just asking for a task to be done, you’re competing for developer time alongside product features, bug fixes, UX improvements, and cross-functional initiatives. And in that world, SEO doesn’t always come first.

Developers don’t ignore SEO tasks because they’re dismissive.

They ignore them because the request hasn’t been framed in a way that resonates. If you want your work to be prioritised, you need to stop treating it like a marketing checklist and start connecting it to outcomes developers, and the business, care about.

Frame SEO Recommendations Around Business Impact

Framing a recommendation as “good for SEO” isn’t enough.

In fact, leaning too heavily on SEO terminology can dilute the perceived value of your ask. Instead, explain what business problem the task solves.

Luke puts it simply:

This isn’t just about language, it’s about aligning your goals with theirs.

When developers understand how an SEO task supports product health or growth metrics, they’re much more likely to care, and act.

Explain the Why, Not Just the What

Framing your ask is one thing, but your delivery matters too.

Hannah highlights the importance of simply taking the time to explain.

Too often, SEO tickets land with no real context... just a list of to-dos. But developers are balancing priorities you may not even be aware of. A missed canonical tag might seem obvious to you, but without the explanation of why it matters and what it impacts, it may be dismissed as low priority.

Building shared understanding often starts with a conversation, not a ticket.

Build Trust Before You Need It

Of course, none of this matters if the only time you talk to your developers is when you’re chasing a fix. Strong collaboration is built in the quiet periods, not in the middle of a sprint.

By showing up when things are calm, expressing interest in what they’re working on, acknowledging their constraints, sharing the outcome of past fixes... you build credibility. That trust compounds over time and makes collaboration much smoother when the next high-priority task lands.

Make SEO Feel Like a Core Function, Not a Bolt-On

The most effective SEOs don’t fight for SEO to matter.

They prove it does.

By translating SEO recommendations into business outcomes, by opening up communication instead of issuing instructions, and by investing in relationships over time, they position SEO as a core part of building a successful product, not a box-ticking exercise.

But getting developers to care is only the first step.

Making things happen, consistently and at scale, requires strategy, structure, and clarity.

Let’s take a look at what actually works when it comes to getting your SEO tickets implemented.

What Actually Works: Getting SEO Tasks Implemented

Even when the SEO case is strong, implementation often lags.

Tickets get logged, but nothing moves. Weeks pass. The issue remains unresolved.

But some SEOs break that cycle... not by shouting louder, but by communicating better, collaborating smarter, and proving impact.

Anchor Every Ask to a Tangible Outcome

For Stefan, implementation starts with impact.

His tickets don’t just describe what’s broken, they explain what the business stands to lose if it isn’t fixed, and what it stands to gain if it is. Whether that’s improved rankings, increased traffic to key converting pages, or better crawl paths, the value is crystal clear.

And when fixes go live? He makes sure the developers know what they helped achieve.

Collaborate, Don’t Just Delegate

Getting work done doesn’t mean handing it off and waiting. Hannah explains that showing a willingness to help, or simply to ease the load, can accelerate delivery and build trust.

Even if you’re not writing code, offering to support testing, QA, or documentation can show you're a collaborator, not a bottleneck.

Write Developer-Friendly Tickets

You might know exactly what needs fixing, but if the developer can’t understand the ask, nothing happens. Clarity is everything.

That means ditching jargon, using the right ticket templates, and aligning with their workflow... whether that’s Jira, Trello, GitHub, or something else. The more your ticket reads like theirs, the faster it gets actioned.

Clarity is not just a courtesy, it’s a competitive advantage.

So how do you actually go about writing tickets that get picked up by devs?

Packaging SEO Tickets to Avoid the Backlog Black Hole

Even the most urgent SEO fixes can end up buried in a backlog if they’re not communicated effectively.

That’s not always because of lack of interest; it’s often because the ticket itself is vague, overloaded, or missing critical context.

In development teams, clarity is everything.

Developers are making decisions constantly about what to pick up next. If your request doesn’t feel actionable, or if it looks like it’ll require back-and-forth to decode, it’s likely to be postponed.

The solution is to write better tickets.

Clarity Cuts Through the Noise

For Hannah, the key to getting SEO tasks picked up is being unambiguous from the start.

Her approach is refreshingly simple. Each request she raises answers the following:

• What am I asking for?
• Why am I asking for it?
• Why is it important?
• When do I need it by?
• What might the developer need from me to get started?

This format not only reduces the chance of misinterpretation, it respects the developer’s time. When you pre-empt questions and provide full context, you allow them to assess and act, rather than investigate and chase.

Use Ticket Formats Developers Already Understand

Clarity also means speaking the language of the team you’re working with, and for Luke, that means aligning SEO tickets with how Product and Engineering already operate.

His preferred structure mirrors the way product teams scope work:

• Title: Clear and descriptive
• Overview: What’s the request? What’s the underlying problem?
• Value: What’s the benefit to the business if it’s fixed?
• Steps to Reproduce (for bugs): How can the issue be replicated?
• Acceptance Criteria: What does “done” look like?
• Resources: Relevant links, screenshots, documentation, etc.

A single ticket should only contain one task. Multiple problems mean multiple priorities, and that requires multiple entries.

Get Specific... It Builds Credibility

Being precise doesn’t mean you need to write code, but knowing enough to frame a request in terms a developer understands can dramatically improve your chances of getting it actioned.

Even a nod to the specific template, file, or component affected shows that you’re not throwing work over the fence, and that you’re working alongside them.

Standardise Your Ticketing Workflow

At Priory, Stefan has taken it a step further... turning effective ticket writing into a repeatable process.

Each ticket he creates follows a consistent format:

• A clear summary
• Detailed description of the issue
• Affected URLs
• The expected fix
• Priority level
• Acceptance criteria

This level of clarity removes ambiguity, builds confidence, and makes SEO tickets feel like any other structured dev request... not an external interruption.

Don't Just File a Ticket, Build a Business Case

When tickets sit untouched, it’s rarely because they’re unimportant. It’s often because they weren’t framed clearly or confidently enough to be prioritised.

Think of every SEO task not as a request, but as a small pitch: here’s the issue, here’s what it’s costing us, here’s the fix, and here’s what happens when we resolve it. Clarity isn’t just polite, it’s persuasive.

And notice how we keep coming back to this same topic of building a business case?

The more your ticket reads like a well-scoped task in a shared system, rather than a vague plea from a disconnected team, the more likely it is to be actioned.

Making the Internal Case for Developer Time

Every in-house SEO eventually runs into the same roadblock: needing developer time for work that’s critical to organic performance... and realising just how scarce that time is.

There are always jobs that SEOs can execute alone. But dev time is one of the most finite, heavily protected resources in any business. And to secure it, submitting a ticket often isn't enough. You need influence.

Getting your recommendation prioritised means positioning it as more than just an SEO issue. You need to frame it in terms of business risk, commercial impact, and customer experience, and then navigate internal politics with clarity and empathy.

Reframe SEO Issues as Business Problems

If you want traction, stop talking solely in SEO terms. That’s the advice from Luke:

This means moving beyond rankings or technical fixes. A broken canonical isn’t just an indexation problem, it’s wasted crawl budget and diluted authority. An uncrawlable product category isn’t just a coverage issue, it’s revenue being left on the table because customers can’t find what they’re searching for.

When you translate SEO tasks into missed revenue, poor user journeys, or reputational risk, stakeholders stop seeing them as technical distractions, and start treating them as business priorities.

Highlight Risk and Reward in Every Request

Stefan takes a pragmatic, decision-maker-friendly approach when asking for developer time.

That means showing the cost of inaction and the potential upside if the issue is resolved. For Stefan, that often includes traffic loss projections, lead generation impacts, crawl budget inefficiencies, or even UX trade-offs that affect brand perception.

By grounding SEO requests in commercial outcomes, he positions his team not as requesters, but as revenue enablers.

Balance Advocacy with Empathy

Even the best cases can clash with competing priorities. The most successful SEOs at getting stuff done understand that. They don’t push blindly, they listen first.

Sometimes there’s a valid business case for dev teams to be focused elsewhere. That doesn’t mean giving up, but it does mean being strategic. Hannah shares context, outlines the implications of delay, and keeps the conversation open:

That kind of collaborative posture helps turn a “not now” into a “next sprint.”

Know When, and Where, to Escalate

Sometimes even a well-argued case doesn’t move forward; not because it’s weak, but because it’s stuck in the wrong layer of decision-making.

Escalating doesn’t mean going over someone’s head.

It means understanding how product decisions are made inside your organisation, and ensuring your request is framed correctly at the right level.

That might mean looping in a PM, or getting your case on the roadmap planning agenda.

Developer Time Isn’t a Favour

You’re not begging for time. You’re advocating for a business investment: in visibility, in performance, in sustainable growth.

To win that investment:

• Translate technical issues into business risks
• Use language aligned with commercial goals: conversions, leads, revenue
• Respect trade-offs and help reduce scope or complexity when needed

Winning developer time takes more than a compelling audit and corresponding ticket(s).

Earning Developer Trust and Credibility

Securing developer time for one task is a win, but earning ongoing trust from your engineering team is where the real magic happens. When developers trust your judgment, understand your goals, and see the impact of the work you’re championing, they don’t just act on SEO requests, they start anticipating them.

That kind of trust isn’t granted by default. It’s built through consistent behaviours: clarity, respect, collaboration, and recognition.

Respect Developer's Time, and Only Escalate When It Matters

For Hannah, trust starts with knowing when not to ask for help.

In fast-moving development teams, triage is a daily reality. If every request is a fire drill, yours won’t stand out. But when developers know that your asks are well-considered and necessary, they’re far more likely to engage, and to do so quickly.

Gratitude and discretion go further than urgency ever will.

Understand Their Tools and Speak Their Language

Developers often operate in a parallel universe... one with its own tooling, processes, and constraints. If you want credibility, meet them there.

You don’t need to write production-ready code. But knowing how your site is structured, what deployment cycles look like, and which systems are in play shows that you respect the engineering process, not just the SEO outcome.

That awareness signals that you're not just chasing a metric... you’re thinking holistically about how your recommendations fit into the broader product.

Be Thoughtful, Kind, and Prepared

According to Luke, there’s no secret shortcut to trust. It’s earned through how you engage... every single time.

That means writing strong tickets, turning up to meetings with context in hand, and being available when clarification is needed. It also means not panicking when something slips... and recognising that devs, like SEOs, are juggling multiple moving parts.

Trust doesn’t just come from your strategy. It comes from how you show up day-to-day.

Celebrate the Wins Together

Want a developer to prioritise your next SEO ticket? Show them what happened after the last one was implemented.

Whether it’s a traffic increase, better crawlability, or stronger conversion performance, he makes sure the development team sees their role in the outcome.

Recognition creates ownership. And ownership builds the kind of partnership that makes SEO implementation smoother over time, because the devs aren’t just supporting your work, they’re invested in it.

Trust Isn’t a One-Off, It’s an Ongoing Investment

Developer trust is earned gradually, and it’s maintained through consistent, respectful collaboration.

It means:

• Speaking their language
• Doing your homework
• Recognising trade-offs
• Sharing success
• And never forgetting that you’re on the same side

The most effective SEOs don’t push tasks blindly, they build partnerships.

When Developers Push Back: How to Respond

Even with airtight tickets, clear business cases, and well-framed requests, you’ll still face pushback. It’s part of working in cross-functional teams... especially when technical SEO requires development time and resources that are already stretched thin.

But pushback isn’t the end of the road.

Often, it’s not even a “no,” it’s a prompt for deeper conversation.

It might reflect a misunderstanding, a resource constraint, or a genuine technical challenge you hadn’t considered. The real test isn’t whether you experience resistance, it’s how you respond when it happens.

Here’s how experienced SEOs navigate those moments of friction and turn them into forward motion.

Get Curious About the Pushback — Don’t Get Defensive

The first step is simple: find out what’s behind the resistance. Hannah recommends starting with empathy and inquiry.

Assumptions are dangerous. If you jump to conclusions or take pushback personally, you risk escalating something that could’ve been solved with a five-minute chat. Understanding the real reason allows you to respond constructively, and often, collaboratively.

Use Objections as a Path to Clarity

Sometimes, pushback reveals more than resistance... it reveals gaps in your original brief or blind spots in the solution.

Maybe your ask introduces UX concerns. Maybe it adds performance weight. Maybe it conflicts with another product initiative. By being open to feedback, you can often refine your recommendation, or co-create a better one.

Pushback isn’t always a wall. Sometimes it’s a window.

Escalate Carefully, and Only When Needed

There are rare occasions when pushback is rooted not in feasibility, but in misaligned priorities or lack of SEO understanding. That’s when escalation becomes appropriate, but only after all other routes have been explored.

Escalation isn’t about forcing compliance.

It’s about making sure your request is evaluated by the right people, with the right context. But it works best when you’ve already done the work to frame your ask around business impact, not just SEO importance.

Stay Persistent, But Choose Your Battles

Not every issue will be prioritised on the first attempt. That’s not failure, it’s reality. According to Dominic, the key is to keep the door open.

If the business case is strong and the need persists, don’t give up... but don’t become adversarial, either. Respectful persistence, especially when combined with an understanding of timing and trade-offs, often wins out in the long run.

Aim for Flexibility, Not Rigidity

Sometimes the exact fix you’re proposing isn’t feasible, but a variation of it might be. The goal isn’t to be right, it’s to get the problem solved.

This is where strategic SEOs shine... they’re firm on the outcome, but flexible on the implementation. By being open to alternatives, you show that you’re focused on business value, not just dogma.

Pushback Isn’t Rejection, It’s Part of the Process

If there’s one takeaway from all of this, it’s that pushback is not a sign you’ve failed. It’s a sign that you’re working on something that matters... and that you need to keep collaborating to get it across the line.

When resistance shows up:

• Ask first, don’t assume.
• Use the feedback to improve your case.
• Escalate thoughtfully, only when needed.
• Be persistent, but respectful.
• Stay focused on the goal, even if the solution shifts.

When you handle pushback well, you don’t just get the work done, you build trust that carries into the next project.

Advice for SEOs Struggling to Get Technical Changes Implemented

If you’re an in-house SEO watching critical recommendations sit untouched in the backlog, struggling to get traction with dev teams, or feeling like SEO is constantly deprioritised, know that you’re not alone.

Even the most experienced SEOs have been there. The difference between those who stay stuck and those who get things done isn’t luck or job title... it’s mindset, communication, and relationships.

Here’s what our contributors recommend if you’re feeling frustrated, blocked, or unheard.

Don’t Just Do SEO... Drive the Business Forward

One of the most important mindset shifts you can make is to stop thinking of yourself as just “the SEO person.” Luke puts it plainly:

That doesn’t make you powerless, it gives you a responsibility. You have to connect the dots between what you’re asking for and the broader goals of the business. Because no one else will do it for you.

When you shift the narrative from “we need to fix this for SEO” to “fixing this will grow traffic, improve UX, or unlock revenue,” people start to listen.

Relationships Are Your Real Growth Lever

SEO success inside an organisation isn’t just about strategy or audits, it’s about the relationships you build.

Stefan’s advice is tactical and human. Be clear in your asks. Tie everything back to business value. Share the results when work goes live. Celebrate the wins... together.

That’s how you shift perception. You stop being seen as the person who creates more work, and start being seen as someone who helps deliver results.

Educate Without Ego

Frustration is normal... but it’s rarely productive. Instead, Hannah advocates for empathy and patience.

Your colleagues might not understand the urgency of an indexing issue or the technical nuance of a request you've made. That’s OK. Your job is to bridge that gap, not bulldoze through it.

The best educators aren’t the loudest, they’re the clearest.

Learn Enough to Unblock Yourself

You don’t need to be a developer to move faster, but learning the basics can go a long way. Dominic encourages SEOs to upskill where they can.

Even being able to test changes in staging or understand the structure of the codebase builds credibility, and reduces back-and-forth.

It’s not about replacing your dev team... it’s often about meeting them halfway.

Influence Is a Core SEO Skill

If you’re stuck, it’s time to reframe your role.

You’re not just reporting problems... you’re building business cases.
You’re not just filing tickets... you’re driving priorities.
You’re not just requesting time... you’re earning trust.

The most effective SEOs don’t wait for implementation. They create the conditions that make it possible, and repeatable.

Hard Truths from the Front Line: What In-House SEOs Wish They’d Known Sooner

Even the most experienced in-house SEOs don’t get everything right the first time. From overlooked risks to misjudged priorities, the learning curve is steep, and often shaped by hard-won lessons.

To wrap up, our contributors reflect on the insights they’ve gained through trial, error, and the occasional implementation failure.

If you're navigating the same challenges, these reflections can help you avoid common pitfalls and refine your approach.

You Can’t Just Send SEO Tasks, You Have to Sell Them

Many SEOs assume that logic will carry the day... that if a recommendation is technically sound, it will be implemented.

But internal influence often matters more than technical merit. If you’re not actively framing your work around its impact, you risk being ignored, no matter how valid your request.

Previous Wins Don’t Guarantee Future Support

Momentum fades quickly in product teams.

Priorities change. People move on. What worked last quarter may not land today.

That’s why effective in-house SEOs treat every sprint as a fresh opportunity to align SEO with business goals, not a continuation of past success.

Clarity Upfront Prevents Chaos Down the Line

Ambiguity is expensive.

When a developer misreads a ticket, you don’t just lose a sprint... you lose trust. The best way to avoid that is by being obsessively clear from the outset.

Spell out what needs to be done, why it matters, and what success looks like.

If You Ignore UX, Expect Pushback

Stefan shared one particularly costly lesson from his time agency-side, working with Tesco.

On paper, the SEO recommendation made perfect sense: adding internal links from product pages to category pages to drive discoverability and improve rankings.

The implementation never happened because the team hadn’t factored in how it might disrupt the user experience.

SEO doesn’t live in a vacuum. If a fix helps Google but harms users, it won’t go live. The strongest strategies consider both.

Learn from the Pain... Then Get Smarter

These lessons are a reminder that implementation isn’t just a matter of knowing what to fix, it’s about understanding how to get it fixed. That means framing recommendations with empathy, presenting business cases with clarity, and balancing SEO goals with the broader product and user context.

When something stalls, it’s worth asking:

• Have I clearly articulated the business impact?
• Does this make sense from a dev perspective?
• Could this cause friction elsewhere... like in UX?

Implementation Is Where SEO Wins — or Fails

The relationship between SEO and development isn’t just operational, it’s foundational. When it works, technical changes happen, performance lifts, and SEO becomes a core driver of growth. When it breaks down, even the best strategy won’t move the needle.

The most effective in-house SEOs know that success isn’t just about identifying what’s wrong, it’s about knowing how to get it fixed. That requires influence, not just insight. Trust, not just tickets. And above all, a mindset focused on collaboration over control.

You don’t need a louder voice or more authority to get SEO implemented.
You need clarity. Empathy. Persistence.
You need to show why it matters, and make it easy to say yes.

So next time you raise a technical SEO request:

• Make it clear.
• Make it relevant.
• Make it collaborative.

Because at the end of the day, implementation is where SEO lives or dies, and the best SEOs don’t just make the case.

They make it happen.