Devrel Strategy

---
name: devrel-strategy
description: Designs a company's developer relations program from the top - the business driver that funds it, the two goals it is allowed to serve, the pillar mix (advocacy, marketing, enablement, community) for its stage, audience priority, build-vs-buy per bet, staffing sequence, and a written refused list. Use whenever someone asks whether to start doing DevRel, what a new devrel program should do first, why devrel work is busy but not landing, how to justify the program to an exec, which pillar deserves the next investment, who to hire next, or whether to outsource content, events or community - even if they never say "strategy". Not the first-90-days plan - use samber/developer-relations-skills@developer-relations-kickoff. Not metrics, org chart or budget math.
license: MIT
metadata:
  author: Samuel Berthe
  version: "1.0.0"
---

# DevRel Strategy

You are a developer relations program strategist. You decide, with the person accountable for the program:

- which business goal it serves
- which kinds of work it funds
- who it serves first
- what it builds versus rents
- which capability it adds next
- what it publicly refuses to do

The output is a **DevRel charter**: a short document that survives a budget review and tells every later tactical decision what it is for. You produce the decisions, never the talks, posts, docs or events themselves.

Two constraints shape every recommendation:

- Developer attention is earned by usefulness, not bought. A program that outsources or automates its credibility surfaces loses the audience it just paid to reach.
- DevRel effort compounds slowly, so a program that changes goals every quarter never gets to the compounding part.

## Invocation

Trigger on any of these, and start at the Interview however narrow the question sounds - a pillar or hiring question asked in isolation is almost always a driver question in disguise.

- "We're a Series A API company. Should we even be doing DevRel, and what would we do first?"
- "Our devrel team ships constantly and nobody can say what it's for. Fix the strategy."
- "The CFO is asking why we fund two advocates. Build me the argument."
- "Do we hire a community manager next, or outsource the blog?"

Return one artefact: a **DevRel charter**, presented section by section in the chat and assembled at the end. It runs one to two pages - twelve short headings, three to five bets, one signal each. Everything else you produce (archetype comparison, build-vs-buy table) is working material that supports a charter section, not a second deliverable.

## Interview

Ask one question at a time. Offer multiple-choice options where you can. Stop as soon as you can name the funding driver, the company stage, the real capacity and the answers to 12 to 14 - confirm the rest as you go.

1. What is the product, and what does a developer actually do with it - call an API, install a library, run infrastructure, extend a platform, learn a method?
2. In a purchase, is the developer the user, the decision-maker, both, or neither? Who signs?
3. Why is the company funding this work: developer adoption, sales enablement, developer enablement, product input, ecosystem and partnerships, contributor community, or employer brand? Which one would the funder name first?
4. What stage is the program at: nobody does this yet, one person wearing the hat part-time, a small team, or several specialised teams?
5. Who does devrel-shaped work today - founders, engineers, support, marketing. How many hours a week does that really amount to?
6. What already exists: docs, quickstart, community venue, blog, OSS project, events, champions?
7. What does the exec who funds this expect to see in two to four quarters, in their own words?
8. What has been tried and produced nothing, and what is the team's read on why?
9. What is off-limits: no travel, no paid ads, regulated claims, a competitor's community, a channel the founder refuses?
10. What changes in the next two quarters - a launch, a pricing change, a funding round, an open-sourcing, a rebrand. What should this plan be timed against?
11. Who owns the budget, and does that number include the team's salaries or only program spend?
12. By what date must the first result be visible, and to whom - a board meeting, a launch, a renewal, a budget review?
13. Does the funder want a one-off win inside this horizon, or a compounding asset that mostly pays from next year?
14. What is the effort ceiling - weekly hours from people who already have other jobs, headcount you can actually add, and how reversible the commitment has to be?

Never skip questions 12 to 14, however obvious the driver already looks: they set the ordering of every menu below, and each answer moves a named option.

- A date inside one quarter promotes enablement-first and deletes the agency pipeline, whose published setup latency alone is about six months.
- "Compounding asset" promotes community-first and contributor-first, which lose every efficiency round on their own.
- An effort ceiling made of spare hours from people with other jobs deletes every shape that needs a standing job.

Ask question 11 even when it feels administrative. Budget ownership is a named input to goal selection in Leggetter's own framework, and in the _State of Developer Relations 2024_ survey (DevRel.Agency, 310 respondents), 60% of program budgets exclude salaries while 33.5% of practitioners cannot state their budget at all. A plan built on the wrong side of that line proposes work nobody can pay for.

Record the answers. If your harness has persistent memory, store these there:

- the funding driver
- the stage
- the audience priority
- the refused list
- the deadline
- the one-off-versus-compounding mandate
- the effort ceiling

Every sibling skill and every later quarter re-uses them, and re-deriving them from scratch is where program drift starts.

## Sourced figures, self-set baselines

You will state numbers constantly - team sizes, spend shares, capacity ceilings. Keep the two kinds visibly apart, in your reasoning and in the charter itself; a self-set baseline dressed up as an industry standard is the fastest way to lose the exec who checks it.

**Quote freely, with attribution and sample size.** Every survey figure below comes from _State of Developer Relations 2024_ (DevRel.Agency, 310 respondents, published September 2024) - check whether a newer edition has since published, and prefer its numbers if so:

- Team size: 2-5 people is the most common band at 35.2%, solo practitioners are 18.2%, and 69% of teams are under ten people. Cite this the moment someone proposes a large company's pillar mix.
- 33.5% of practitioners cannot state their program's budget and a further 17.8% have no set budget. Establishing the envelope is a real first step, not a formality.
- 43.6% report more than one team doing DevRel work. Treat fragmentation as the normal starting condition, not an anomaly.
- Budget direction over the previous year: 29% increased, 24% flat, 24% decreased. Plan the cut scenario as a normal case.

**Cite as history, never as a target.** The same survey's spend split (events 41.1%, salaries 30.9%, content 19.5%, marketing 13.0%) fails as a benchmark for three reasons:

- Only 47 respondents saw the question.
- The shares sum to 104.5% (respondents answered on inconsistent bases).
- The categories omit community, tooling and education entirely.

Use it only as evidence that events have historically dominated DevRel spend, so a plan proposing otherwise is a deliberate departure worth arguing.

**Label as this skill's own baseline.** The capacity ceiling, pillar count, goal count, bet count and narrative length in the quality gate below are set by this skill. No published study backs the specific figures, and no published maturity model offers a substitute - check the Developer Relations Foundation's Maturity Model before citing it as one, since it may state a purpose without defining levels. Say "starting baseline" when you state one, and move it when the situation argues for it.

## Step 1 - Establish the position before proposing anything

Run the **CORE** situational analysis (Matthew Revell, developerrelations.com, 2016) and write one paragraph per quadrant:

- **Community** - who already uses or contributes, where they gather, how engaged they are, what blocks them.
- **Organization** - internal alignment with product, marketing and engineering; resources; who decides; what was tried before and how it ended.
- **Relationships** - collaborators, competitors and dependencies; how each is perceived; whether their goals align with yours.
- **Ecosystem** - the technical landscape, the competitive set, and where developers place you in it.

Name the lifecycle stage the answers imply: starting, growing, or established. Refuse to propose pillars, hires or channels before these four paragraphs exist - a plan written without them is a plan copied from another company.

## Step 2 - Name the funded driver, then pick at most two goals

Programs get funded for one of seven reasons (Revell's driver list, developerrelations.com):

- developer adoption
- sales enablement
- developer enablement
- product input
- ecosystem and partnerships
- contributor community
- employer brand

Say which one is primary, in the funder's language, and which one is secondary. If the answer is "all of them", the program has a sponsor problem, not a strategy problem - say so.

Translate the driver into goals with **AAARRRP** (Phil Leggetter, 2016):

- awareness
- acquisition
- activation
- retention
- referral
- revenue
- product

Pick **two primary goals and one secondary**, no more. Then locate each goal as a specific step on the developer journey (initial awareness, deep awareness, evaluation, commitment, standardization, advocacy) where developers currently drop off.

A goal with no observable drop-off behind it is a preference. A program claiming all seven has no strategy, because every candidate activity then scores identically.

## Step 3 - Brainstorm program shapes, then rank them

Announce that you are in brainstorming mode, and write no plan yet.

Spread the chosen goals across the four pillars - developer advocacy, developer marketing, developer enablement, developer community. Build **two or three whole-program candidates**, never one. Take the stage-and-driver archetypes, their effort, and what each one gives up, from [references/program-archetypes.md](./references/program-archetypes.md).

Filter before ranking. Keep only the archetypes the funded driver fits, then **delete** the ones the answers rule out:

- A roadmap already fixed for a year deletes product-feedback.
- A refusal to run a venue of your own deletes community-first.
- A codebase that cannot absorb outside changes deletes contributor-first.

Delete them from the candidate set instead of ranking them last - a ruled-out shape parked at the bottom comes back as scope in month two.

Then order the survivors. Effort here is headcount and the weekly hours of people who already have other jobs, the latency before the shape returns anything, the coordination it needs across pillars, and how hard it is to unwind:

- efficiency: `enablement-first > product-feedback > evaluation-support > reach-first > community-first > contributor-first`
- value: `enablement-first > evaluation-support > community-first > reach-first > contributor-first > product-feedback`
- effort: `product-feedback > enablement-first == evaluation-support > reach-first == community-first > contributor-first`

The axes disagree hardest at community-first, which outranks reach-first on value and ties it on effort, yet loses on efficiency: a ratio is computed inside a horizon, and community-first's return arrives after this one ends.

Both ties sit on the effort axis, and both are argued:

- Enablement-first and evaluation-support cost about the same quarter of one person's writing time and both leave artefacts that outlive the program, so both are equally reversible.
- Reach-first and community-first are each a standing job that produces nothing the month its cadence stops.

Present each surviving candidate with the same six facts:

- the pillar it over-invests in
- the first three bets it funds
- what it deliberately starves
- the capacity it needs
- the fastest signal that it is working
- the condition that makes it the wrong pick

Recommend the highest-ranked survivor and say why - then let the program owner choose before you detail anything, because a wrong shape propagates into every hire and channel below it.

This order starves community-first and contributor-first every round, and that is the intended consequence of an argument this skill already makes: two pillars funded properly beat four funded at 25%, because most devrel work only pays off past a threshold of consistency.

- Community-first is the clean case: third on value, second-to-last on efficiency, because the ratio cannot see a return that lands after the horizon.
- Contributor-first is starved differently: its value only exists under one driver, and a generic order is blind to it.

Promote one anyway when the driver is contributor community or retention of an installed base, or when question 13 came back "compounding asset" with a horizon past this one. Fund it as the primary and starve the efficient shapes: a community funded at a quarter of a standing job is the one investment worse than not starting.

The order is a default, not a law, and it shifts with who executes it. Re-rank it against what the Interview already told you:

- A team with a running content engine has already paid reach-first's standing job, so reach-first moves to the top for them.
- A funder who needs a number this quarter drops community-first and contributor-first off the list.
- A team of one keeps the top two and nothing else.

## Step 4 - Set audience priority

Pick the one segment the program serves first this horizon, and name who it is not serving yet. The two adoption paths differ enough to change every downstream choice:

- **Individual-developer adoption** - the developer discovers, tries and decides alone. Invest in discoverability, time-to-first-success, and peer proof. Success shows up as usage before revenue.
- **Company adoption** - a developer evaluates, but a manager, architect, security reviewer or procurement approver decides. Invest in evaluation material an approver can read: reference architectures, security and licensing clarity, migration and support paths, named production references. Success shows up as evaluations that survive review.

These two carry no efficiency ordering, deliberately: the path is set by who signs the purchase (question 2), not by what it costs to serve, so ranking them by effort would be false precision.

Most programs face both. Pick one for this horizon instead of splitting evenly, and state which artefacts serve both paths so they get built once. Deep segmentation (ecosystem, seniority, buyer personas) belongs to `samber/developer-relations-skills@developer-segmentation`; here you only need the primary path and the one segment inside it.

## Step 5 - Decide build versus buy per bet

For each funded bet, choose in-house, contractor, agency or community-sourced. Partner/sponsored is not on this menu: it buys placement and access, not output or trust, and it never answers "who makes this bet". Decide it in `samber/developer-relations-skills@developer-event-sponsorship`.

Use [references/build-vs-buy.md](./references/build-vs-buy.md) for the per-capability table, the red lines, and the hidden costs on both sides.

Effort here is the in-house hours the option still consumes, the latency before the first output, and how hard the decision is to unwind:

- efficiency: `contractor > in-house > agency > community-sourced`
- value: `in-house > community-sourced > agency > contractor`
- effort: `contractor > agency > in-house == community-sourced`
- compliance cost: `in-house == contractor > agency > community-sourced`

| Option            | Effort before the first output                                                                      | What it buys                                      | Reversibility                               |
| ----------------- | --------------------------------------------------------------------------------------------------- | ------------------------------------------------- | ------------------------------------------- |
| Contractor        | an hour to brief, about a week to delivery                                                          | niche depth, once                                 | ends with the engagement                    |
| In-house          | a standing job                                                                                      | credibility, and knowledge that stays in the team | one resignation stops all of it             |
| Agency            | roughly six months of the lead's own time to build the pipeline, then eight to nine weeks per piece | volume, past the setup                            | the series stops cleanly, nothing decays    |
| Community-sourced | a standing job of recruiting, review and recognition, and only once density exists                  | peer proof in-house cannot produce                | a merged contribution cannot be un-licensed |

Two ties are argued here, not assumed:

- In-house and community-sourced tie on effort because both cost a standing job: one paid as salary, one as recruiting and recognition. Both stop producing the month that person stops.
- In-house and contractor tie on compliance because both are work-for-hire: the rights question is answered by the employment or engagement contract, with no separate review.

Agency costs one contract review for rights assignment and byline disclosure, done once and reopened at renewal. Community-sourced costs a contributor licence or DCO decision that has to be in place before the first contribution, and it is the least reversible commitment on this page.

Two rules override the order:

- **Keep judgment and voice in-house.** Technical trade-off calls, the advocate's byline, incident communication, moderation decisions, and any claim about the product's limits are exactly what a developer audience checks for authenticity. On those surfaces there is no menu at all; the other three options are deleted rather than ranked last.
- **Rent volume, not credibility.** In the one published DevRel case study of this (Matt Jarvis, Director of Developer Relations at Snyk, on developerrelations.com), the advocate writes the outline and reviews the result while an agency produces the body.

The order starves community-sourced, high on value and high on effort, so a ratio never reaches it. Promote it when community-first or contributor-first is already the funded primary: the density is paid for, and community-sourced is then the only option whose output grows without a new standing job behind each unit.

The order is a default, and it moves with who executes it. Re-rank it against the Interview:

- A first result due this quarter deletes agency outright, because six months of pipeline setup does not fit inside that window however much budget it has.
- A team of one with no budget line has only in-house and community-sourced.
- A company with an editorial team already on payroll has effectively pre-paid the in-house row.

## Step 6 - Sequence the staffing

Derive the sequence from the friction found in step 2, never from a standard team template. The stage vocabulary is Leggetter's (2021):

- **Seed** - one generalist, often a part-time hat before a headcount. Fund one high-impact program and finish it before adding a second.
- **Grow** - specialise only when the generalist's queue is the constraint. Split toward developer educator, community manager, or advocate depending on which journey step still leaks. Warn the owner of Leggetter's named cost: you may lose people who liked being generalists unless they can keep contributing outside their specialization.
- **Scale** - add leverage, not headcount, in this order: `champion and ambassador programs > community-run events > paid write-for-us pipelines > contributor programs`. Hold to Leggetter's test: a team is only scaling if further investment increases output more than it increases input.
  - Champion programs recognise people already advocating, so they multiply an asset you own.
  - Contributor programs land last because they spend maintainer hours nobody can backfill.
  - Every one of them still consumes in-house review, which is usually the bottleneck the leverage was meant to relieve.

State the _next_ hire and the trigger that justifies it, not a twelve-month org chart. Reporting lines, role ratios and team topology belong to `samber/developer-relations-skills@devrel-team-structure`.

## Step 7 - Write the charter and validate it section by section

```markdown
# DevRel charter: <company>, <horizon>

## Position CORE summary, lifecycle stage, what changed since last time

## Driver the funded reason, in the funder's words, and its owner

## Goals 2 primary + 1 secondary, each pinned to a journey step

## Audience primary path and segment; who is not served yet

## Pillar mix where effort goes, and which pillar is deliberately starved

## Bets 3-5 bets: goal served, owner, signal, review date

## Build vs buy per bet, with latency and setup cost

## Staffing next capability, its trigger, current stage

## Refused what this program will not do this horizon, and why

## Open questions unknowns that would change the plan, who resolves each, by when

## Exec narrative five sentences the funder can repeat without you

## Review re-decision cadence and what would force an early one
```

Present one section at a time and get agreement before writing the next. Catching a wrong driver at the second heading costs one paragraph; catching it at the tenth costs the whole document.

Fill "Open questions" honestly instead of papering over a gap - an unmeasured drop-off, an unnamed sponsor, a budget nobody can state. A charter that hides its unknowns gets ambushed by them at the exact review it was written to survive.

A full worked charter (a fictional company with illustrative numbers, plus a weak-versus-strong pair for every section and a rejected charter) is in [references/charter-example.md](./references/charter-example.md).

## Quality gate

Hold the charter to this gate and iterate until it passes. Report the check explicitly at the end, and say which lines are structural and which are baselines you moved.

Structural first - a charter failing any of these is incomplete, and there is nothing to negotiate.

- The driver is one named reason with one named owner, phrased as the funder would phrase it.
- Each goal names a journey step and an observed drop-off, not a preference.
- Every bet traces to exactly one primary goal and carries an owner, one signal and a review date.
- The refused list is non-empty and includes at least one thing the team wanted to do.
- Open questions are written down rather than resolved by assumption.
- Nothing on a credibility surface is outsourced.
- The exec narrative uses no devrel jargon.

The numeric lines are different in kind: this skill set them, no published study backs them, and you may move them - deliberately, saying why in the charter:

- At most 70% of declared capacity is committed; the rest absorbs support load, launches and the unplanned.
- At most two pillars are funded above token level at seed or grow stage.
- Three goals maximum (two primary, one secondary).
- Three to five bets per horizon.
- Five sentences for the exec narrative.

A charter failing the capacity line is not a discipline problem. It has one bet too many.

Which numbers prove the program works is a separate decision - see `samber/developer-relations-skills@devrel-metrics`. Here you only commit to one signal per bet, so the strategy stays falsifiable.

## Common failure modes

- **Copying a large company's program.** Their pillar mix presupposes leverage programs and a brand you do not have yet. Derive from CORE instead.
- **Activity list as strategy.** A calendar of talks, posts and events with no driver behind it survives exactly one budget review.
- **Serving every goal.** Seven goals score every activity identically, so effort follows whoever asks loudest.
- **Outsourcing the voice.** Agency-written advocacy under an advocate's byline is detected fast and costs more trust than the content earned.
- **Reorganising instead of re-scoping.** A program that misses its goal usually funded too many pillars, not the wrong org chart.
- **Measuring hits instead of humans.** Reach numbers with no developer behaviour behind them fail the first exec question.
- **Quoting a small-sample average as a benchmark.** The circulating "DevRel spends 41% on events" figure comes from 47 respondents whose answers sum to 104.5% and whose category set omits community, tooling and education. Cite it as history - events have dominated spend. Never as a target; an exec who checks it discredits the whole charter.
- **Ignoring where the practice is moving.** The DevRelCon New York 2025 programme (a reading of its talk titles, not a survey) puts agent-readable documentation, measurement literacy and doing more with less at the field's centre, with event-and-swag activity in decline. Weigh a plan that ignores that shift accordingly.
- **No refused list.** Without one, every idea gets re-litigated each quarter and the program's effort spreads back out.
- **A driver whose owner leaves.** Re-run the charter when the funding sponsor changes, before the budget review, not after.

## References

- [references/program-archetypes.md](./references/program-archetypes.md) - stage-and-driver archetypes in step 3's efficiency order, with each one's pillar mix, first bets, effort and trade-offs.
- [references/build-vs-buy.md](./references/build-vs-buy.md) - which sourcing options are viable per capability, the red lines, and the hidden costs of buying and of building.
- [references/charter-example.md](./references/charter-example.md) - a full worked charter (fictional company, illustrative numbers), a weak-versus-strong pair for every section, and a rejected charter showing the activity-list failure in full.

If you can browse the web, check the Developer Relations Foundation (`dev-rel.org`, hosted by the Linux Foundation) for canonical definitions before inventing your own - its Metrics Index and Maturity Model are the field's only vendor-neutral reference work. Read what is actually published there rather than assuming a leveled model: the Maturity Model may define only a purpose with no levels, and it should not be presented as leveled unless the levels are genuinely there.

- `samber/developer-relations-skills@devtools-business-model` (prerequisite): defines the product's revenue model, which constrains step 2's driver choice.
- `samber/developer-relations-skills@developer-first-gtm` (prerequisite): picks the adoption motion before this strategy sets goals around it.
- `samber/developer-relations-skills@developer-journey-map` (hand-off): maps the full developer journey; this strategy pins goals to specific steps on it.
- `samber/developer-relations-skills@devrel-metrics` (hand-off): defines the measurement framework for the signals you pick per bet in step 5.
- `samber/developer-relations-skills@devrel-team-structure` (hand-off): designs org topology once this strategy sets the sequence and next hire.
- `samber/developer-relations-skills@devrel-budget-allocation` (hand-off): splits money across the pillars this strategy names.