sdlc-developer-relations

name	sdlc-developer-relations
description	Developer Relations (DevRel) program design: advocacy, community, marketing, enablement. Developer experience (DX), developer journey mapping, technical content strategy, community building, SDK strategy, developer onboarding, API playground, developer feedback loops, developer marketing, developer funnel, measuring DevRel.
version	6.0.0-moderate
author	Dinoudon
license	MIT
platforms	["linux","macos","windows"]
metadata	{"hermes":{"tags":["sdlc","developer-relations","devrel","developer-experience","dx","community","advocacy","sdk","developer-marketing","technical-content"],"related_skills":["sdlc-product-growth","sdlc-api-documentation","sdlc-prd-to-production","sdlc-developer-tooling","sdlc-gtm-strategy"]}}

---

name: sdlc-developer-relations description: "Developer Relations (DevRel) program design: advocacy, community, marketing, enablement. Developer experience (DX), developer journey mapping, technical content strategy, community building, SDK strategy, developer onboarding, API playground, developer feedback loops, developer marketing, developer funnel, measuring DevRel." version: 6.0.0-moderate author: Dinoudon license: MIT platforms: [linux, macos, windows] metadata: hermes: tags: [sdlc

When to Use

Trigger when user:

• Plans a DevRel program or developer advocacy team
• Designs developer onboarding or first-run experience
• Creates technical content strategy (blogs, tutorials, videos)
• Builds community (Discord, GitHub, forums)
• Plans SDK/client library strategy
• Designs API playground or sandbox
• Measures developer satisfaction or DevRel ROI
• Asks "how do Stripe/Twilio/MongoDB do DevRel?"

Step 1: The Four Pillars of DevRel

Source: developerrelations.com

┌──────────────────────────────────────────────┐
│              Developer Relations              │
├────────────┬────────────┬──────────┬─────────┤
│  ADVOCACY  │  COMMUNITY │MARKETING │ENABLEMENT│
│            │            │          │          │
│ • Talks    │ • Forums   │ • Content│ • Docs   │
│ • Workshops│ • Discord  │ • SEO    │ • SDKs   │
│ • Feedback │ • Events   │ • Social │ • Tools  │
│ • Evangelism│ • OSS     │ • DevRel │ • Sandboxes│
│            │            │  website │          │
└────────────┴────────────┴──────────┴─────────┘

Step 2: Developer Journey Map

AWARENESS → INTEREST → EVALUATION → ADOPTION → ADVOCACY
    │           │           │            │           │
 Blog post   Docs page   Sandbox     Integration   Share with
 Talk        Tutorial    API key     Production    peers
 Tweet       GitHub      Quickstart  Team rollout  Conference
 SEO         Sample app  Trial       Enterprise    talk

Step 3: Technical Content Strategy

Type	Purpose	Frequency	Owner
Blog post	Deep dives, announcements	2-4/month	DevRel + Eng
Tutorial	Step-by-step how-to	2-4/month	DevRel
Quickstart	First API call in <5 min	Per product	Docs team
Video	Visual learners, YouTube SEO	2-4/month	DevRel
Sample app	Reference implementation	Per use case	DevRel + Eng
Changelog	What's new	Every release	Eng
Newsletter	Community digest	Monthly	DevRel
Case study	Social proof	Quarterly	Marketing + DevRel

Week 1: Blog post (new feature) + Tutorial (how to use it)
Week 2: Video walkthrough + Community spotlight
Week 3: Technical deep dive + Sample app update
Week 4: Newsletter + Changelog + Next month planning

Step 4: SDK & Client Library Strategy

Source: Stripe, Twilio, AWS SDK

1. Idiomatic: Follow language conventions (Pythonic, Go-idiomatic)
2. Typed: Type hints, generics where supported
3. Consistent: Same patterns across languages
4. Minimal: Few dependencies, small footprint
5. Documented: Inline docs, generated reference
6. Tested: 90%+ coverage, integration tests
7. Versioned: Semantic versioning, deprecation warnings
8. Auto-generated: OpenAPI → SDK via openapi-generator or Fern

Step 5: Community Building

Platform	Best For	Pros	Cons
Discord	Real-time chat, gaming/dev	Rich features, bots	Can get noisy
Slack	Professional communities	Familiar UI	Free tier limits
GitHub Discussions	Open source projects	Near code, searchable	Limited formatting
Stack Overflow	Q&A, SEO	High authority	No community feel
Reddit	Broad communities	Large audience	Less control
Forum (Discourse)	Long-form, searchable	Full control, SEO	Higher barrier

1. Active members (monthly active posters)
2. Response time (median time to first reply)
3. Resolution rate (% questions answered)
4. Sentiment (positive/neutral/negative ratio)
5. Champion count (most active helpers)
6. Community NPS (would you recommend?)
7. Content creation (user-generated posts/month)
8. Event attendance (meetup/webinar participants)

Step 6: API Playground & Sandbox

1. Zero friction: No signup needed for basic testing
2. Full fidelity: Sandbox behaves like production
3. Pre-populated: Sample data ready to go
4. Persistent: User's work saved across sessions
5. Shareable: Generate links to share API calls
6. Multi-language: cURL, Python, Node, Go, Java examples

Step 7: Measuring DevRel ROI

Leading Indicators (activity):
- Blog posts published
- Conference talks given
- Community interactions
- SDK releases
- Docs pages updated

Lagging Indicators (impact):
- Developer NPS
- API key signups
- Active API users
- SDK adoption rate
- Developer-sourced revenue
- Community-driven support deflection

Step 8: DevRel at Scale (Company Playbooks)

• API docs are the product (interactive, always up-to-date)
• 7 lines of code to first payment
• SDKs in 10+ languages, auto-generated from OpenAPI
• Stripe CLI for local testing
• DevRel team embedded in product teams
• Result: Developer adoption drives $107B valuation
• "Ask Your Developer" campaign
• TwilioQuest (gamified learning)
• Massive tutorial library
• Super Network community
• DevRel as revenue center, not cost center
• Result: $3.2B revenue (2022)
• MongoDB University (free courses, certifications)
• Community forums with expert answers
• Massive conference (MongoDB World)
• Champions program with clear progression
• Result: 45M+ downloads, $1.2B revenue

Step 8: DevRel Operations & Tooling

Content Management:
├── Docs: Mintlify, ReadMe, Docusaurus, Starlight
├── Blog: Ghost, Hashnode, Dev.to, Medium
├── Video: YouTube, Loom (async), Riverside (recordings)
└── Tutorials: CodeSandbox, StackBlitz, Replit

Community Management:
├── Chat: Discord, Slack, Telegram
├── Forum: Discourse, GitHub Discussions
├── Support: Zendesk, Intercom, Freshdesk
└── Social: Twitter/X, LinkedIn, Mastodon

Analytics:
├── Docs analytics: Mixpanel, Amplitude, PostHog
├── Community health: Common Room, Orbit

Step 9: DevRel Career Ladder

Level 1: Developer Advocate (IC1)
  - Write tutorials and blog posts
  - Give talks at local meetups
  - Answer community questions
  - Build sample applications

Level 2: Senior Developer Advocate (IC2)
  - Speak at major conferences
  - Create technical content strategy
  - Mentor junior advocates
  - Drive SDK feedback to product

Level 3: Staff Developer Advocate (IC3)
  - Define DevRel strategy
  - Build community programs

Pitfalls

1. DevRel as marketing only — If DevRel only does content and events, product feedback loop breaks. Must be bidirectional.
2. Measuring activity not impact — "Published 50 blog posts" means nothing if no one reads them. Track engagement and conversion.
3. Ignoring community health — Toxic communities drive developers away. Moderate actively, set clear codes of conduct.
4. SDK rot — SDKs that aren't maintained become liabilities. Either maintain or don't ship.
5. Docs are never done — Documentation needs continuous updates with every release. Assign owners.
6. One-size-fits-all content — Beginners need tutorials, experts need reference. Create content for each persona.
7. Conference circuit without ROI — Speaking at 20 conferences/year is expensive. Track pipeline generated.
8. No feedback loop — DevRel collects developer pain but doesn't channel it to product. Establish formal feedback processes.
9. Community on rented land — Twitter/Reddit can change rules anytime. Own your community platform.
10. Hiring only extroverts — Best DevRel people are engineers who can write and present, not marketers who code.

Step 10: Developer Marketing & Content Distribution

Owned channels:
  - Company blog (SEO-optimized, long-form)
  - Documentation site (tutorials, guides)
  - YouTube channel (demos, talks, tutorials)
  - Podcast (industry conversations, product deep dives)
  - Newsletter (weekly/monthly digest)
  - GitHub repos (open source, samples, SDKs)

Earned channels:
  - Hacker News (Show HN, Ask HN)
  - Reddit (r/programming, r/webdev, r/devops)
  - Dev.to, Hashnode, Medium (syndication)
  - Stack Overflow (Q&A, documentation)
  - Twitter/X threads (technical insights)
  - Conference talks (KubeCon, re:Invent, PyCon)

Step 11: Developer Experience (DX) Principles

                    ┌─────────────┐
                    │  DELIGHT    │  ← Moments of joy
                    │  (easter    │     (unexpected features,
                    │   eggs,     │      beautiful error msgs)
                    │   polish)   │
                ┌───┴─────────────┴───┐
                │    USABILITY        │  ← Easy to use
                │    (intuitive API,  │     (clear docs,
                │     good defaults)  │      sensible defaults)
            ┌───┴─────────────────────┴───┐
            │      RELIABILITY            │  ← Works consistently
            │      (stable API, uptime,   │     (no surprises,
            │       backward compat)      │      no breaking changes)
        ┌───┴─────────────────────────────┴───┐
        │        FUNCTIONALITY                │  ← Solves the problem

Step 12: Conference & Event Strategy

Title: [Action verb] + [Specific outcome] + [Proof point]
Example: "Scaling to 1M WebSockets: Lessons from Production"

Abstract (150-200 words):
  Hook: Start with a surprising fact or question
  Problem: What challenge does the audience face?
  Solution: What will they learn from your talk?
  Takeaways: 3 specific things they'll be able to do after

Speaker bio (50-100 words):
  - Current role and company
  - Relevant expertise
  - Past speaking experience (if any)
  - Personal touch (hobby, location)

Step 13: Open Source Strategy

1. Open Core:
   - Core product: Free, open source
   - Enterprise features: Paid, proprietary
   - Example: GitLab, HashiCorp, Elastic
   
2. SaaS (Hosted OSS):
   - Self-hosted: Free, open source
   - Managed service: Paid, hosted
   - Example: Supabase, PlanetScale, MongoDB Atlas
   
3. Dual License:
   - Community: AGPL (copyleft)
   - Commercial: Paid license (proprietary use)
   - Example: MongoDB, Redis, Grafana
   

Step 14: Community Building Playbook

Channel structure:
  #announcements: Product updates, releases (read-only)
  #general: Community discussion
  #help: Support questions
  #showcase: Community projects and demos
  #feedback: Product feedback and feature requests
  #jobs: Job postings (weekly thread)
  #random: Off-topic, water cooler
  
Moderation:
  - Community guidelines (pinned)
  - Auto-moderation (spam, toxicity filters)
  - Human moderators (2-3 per 1000 members)
  - Escalation path for serious issues
  - Regular moderator training

Step 15: Developer Onboarding

# Quickstart: [Product Name]
## Prerequisites
- [Language] [version]
- [Package manager]
- [Account/API key]
## Step 1: Install
```bash
npm install @company/sdk
# or
pip install company-sdk
# or
brew install company-cli

Step 2: Configure

export COMPANY_API_KEY="your-api-key"
company init

Step 3: First API Call

const client = new CompanyClient({ apiKey: process.env.COMPANY_API_KEY });
const result = await client.createResource({ name: "Hello World" });
console.log(result);

Step 4: Next Steps

• Full API reference
• Tutorials
• Examples

### Interactive Tutorial Design

Step 16: Hackathon and Event Organization

8 weeks before:
  □ Define theme and challenge
  □ Set date and venue (virtual or hybrid)
  □ Secure sponsors and prizes
  □ Create registration page
  □ Promote on social media and communities

4 weeks before:
  □ Finalize judging criteria
  □ Confirm judges (3-5 industry experts)
  □ Prepare starter templates and APIs
  □ Set up communication channels (Discord, Slack)
  □ Plan workshop schedule

2 weeks before:

Step 17: Content Marketing for Developers

Tutorial post (1500-2500 words):
  Title: "How to [Action] with [Tool/Technology]"
  Structure:
    1. Introduction (what you'll build/learn)
    2. Prerequisites
    3. Step-by-step guide (with code)
    4. Common pitfalls
    5. Next steps
    6. Resources

Comparison post (1000-1500 words):
  Title: "[Tool A] vs [Tool B]: Which Should You Choose?"
  Structure:
    1. Overview of both tools
    2. Feature comparison table

Step 18: API Versioning Strategy

URL versioning:
  GET /v1/users
  GET /v2/users
  
  Pros: Clear, explicit, easy to route
  Cons: URL proliferation, resource duplication

Header versioning:
  GET /users
  Accept: application/vnd.company.v2+json
  
  Pros: Clean URLs, content negotiation
  Cons: Less visible, harder to test in browser

Query parameter:

Step 19: Developer Feedback Loops

Passive feedback:
  - Support ticket analysis (common issues)
  - Community forum monitoring
  - GitHub issues and discussions
  - Social media mentions
  - NPS surveys (quarterly)
  - In-app feedback widget

Active feedback:
  - Developer advisory board (10-15 members)
  - Beta testing program (50-100 users)
  - User interviews (weekly, 5-10 users)
  - Usability testing (monthly)
  - Feature request voting (Canny, ProductBoard)

Step 20: Developer Advocacy Metrics

Content metrics:
  - Blog post views (total, unique)
  - Video views and watch time
  - Social media impressions and engagement
  - Conference talk attendance
  - Podcast downloads

Community metrics:
  - Community size (Discord, Slack, forum)
  - Active members (daily, weekly)
  - Questions answered (community vs support)
  - Community NPS

Influence metrics:
  - Developer signups attributed to advocacy

Step 21: SDK Design

Consistency:
  - Same patterns across all languages
  - Consistent naming conventions
  - Predictable behavior
  - Follow language idioms

Simplicity:
  - Minimal required configuration
  - Sensible defaults
  - Chain-able methods
  - Clear error messages

Example (Python):
```python
## Step 22: Developer Experience Metrics

Time to first API call: Target: <15 minutes Measure: Signup to first successful API call Tools: Product analytics, custom events

Time to value: Target: <1 hour Measure: Signup to first meaningful integration Tools: Product analytics, onboarding flow tracking

Documentation satisfaction: Target: >4.0/5.0 Measure: "Was this helpful?" on doc pages Tools: Feedback widgets, surveys

## Step 23: Technical Content Strategy

Blog posts (weekly):

• Technical tutorials (how to implement X)
• Best practices (security, performance)
• Architecture decisions (why we chose Y)
• Case studies (how customer Z uses product)

Documentation (continuous):

• Quickstart guides
• API reference
• SDK reference
• Integration guides
• Troubleshooting

Video content (monthly):

• Product demos (5-10 min)

## Step 24: Developer Community Programs

Structure:

• Size: 20-50 ambassadors
• Term: 6-12 months
• Selection: Application + interview
• Compensation: Swag, early access, recognition

Requirements:

• Active community member
• Technical content creator
• Event organizer or speaker
• Product advocate

Benefits:

• Early access to features
• Direct line to product team

## Step 25: Developer Marketing

Content marketing:

• Technical blog posts (weekly)
• Tutorials and how-to guides
• Architecture deep dives
• Performance benchmarks
• Security best practices

Community marketing:

• Open source contributions
• Developer meetups (host and sponsor)
• Hackathons (organize and participate)
• Conference speaking
• Podcast appearances

Paid marketing:

## Step 26: Developer Relations Metrics

Content metrics:

• Blog post views and engagement
• Video views and watch time
• Social media impressions and engagement
• Conference talk attendance
• Podcast downloads

Community metrics:

• Community size (Discord, Slack, forum)
• Active members (daily, weekly)
• Questions answered (community vs support)
• Community NPS

Influence metrics:

• Developer signups attributed to DevRel

## Step 27: Technical Evangelism

Responsibilities:

• Speak at conferences (10-20 per year)
• Write technical content (2-4 posts per month)
• Build community relationships
• Gather product feedback
• Represent company externally

Skills:

• Deep technical expertise
• Strong communication (written and verbal)
• Community building
• Product empathy
• Industry knowledge

Measurement:

## Step 28: Developer Experience Design

Simplicity:

• Minimal configuration
• Sensible defaults
• Clear error messages
• Intuitive API design

Consistency:

• Same patterns across products
• Consistent naming conventions
• Predictable behavior
• Follow platform conventions

Reliability:

• Backward compatibility
• Clear deprecation process

## Step 29: Developer Relations Career

Individual contributor track: Developer Advocate I → II → Senior → Staff → Principal

I: Content creation, community support, event attendance II: Strategy, metrics, program ownership Senior: Cross-functional influence, team mentoring Staff: Industry thought leadership, org-wide impact Principal: Industry direction, executive advising

Management track: DevRel Manager → Director → VP

Manager: Team of 2-5 advocates, program management Director: Multiple programs, budget ownership, strategy VP: Org-wide DevRel strategy, executive team member

## Related Skills
  - [sdlc-product-growth](sdlc-product-growth): Product-led growth (PLG), developer-led growth, growth loops, activation funnels, A/B testing, SaaS 
  - [sdlc-technical-writing](sdlc-technical-writing): Technical writing for software companies: documentation strategy, docs-as-code, API docs, runbooks, 
  - [sdlc-platform-engineering](sdlc-platform-engineering): Platform engineering: internal developer portals (IDP), Backstage, golden paths, service catalog, se
## Step 30: DevRel Budget Planning

Personnel (60-70%):

• Salaries and benefits
• Contractors and freelancers
• Interns

Travel (15-20%):

• Conferences (registration, flights, hotels)
• Meetups (local transportation)
• Team offsites

Content (5-10%):

• Video production (equipment, editing)
• Design (graphics, thumbnails)
• Tools (CMS, analytics, hosting)

## Step 31: DevRel Operations

Monday:

• Content planning (review calendar)
• Community check (respond to questions)
• Team sync (weekly standup)

Tuesday:

• Content creation (writing, recording)
• Code examples (build and test)
• Documentation review

Wednesday:

• Community engagement (forums, Discord)
• Feedback collection (from community)
• Product team sync

## Step 32: DevRel Content Calendar

Week 1: Technical tutorial

• Blog post (1500-2500 words)
• Code example (GitHub repo)
• Social promotion (Twitter, LinkedIn)

Week 2: Community spotlight

• Customer story or case study
• Community member interview
• Social promotion

Week 3: Product update

• New feature announcement
• Migration guide (if breaking change)
• Video walkthrough

## Step 33: DevRel Metrics Dashboard

Reach metrics:

• Content views (blog, video, docs)
• Social media impressions
• Conference attendees reached
• Community members

Engagement metrics:

• Content engagement (likes, comments, shares)
• Community activity (posts, replies)
• Event participation (questions, feedback)
• SDK/API usage

Conversion metrics:

• Signups from DevRel content
• Activations from tutorials

## Content
- Blog posts published: [N]
- Videos published: [N]
- Tutorials created: [N]
- Total views: [N]
## Community
- New members: [N]
- Active members: [N]
- Questions answered: [N]
- NPS score: [N]
## Events
- Conferences attended: [N]
- Talks given: [N]
- Workshops conducted: [N]
- Attendees reached: [N]
## Impact
- Signups influenced: [N]
- Activations influenced: [N]
- Revenue influenced: $[N]
- Partnerships initiated: [N]
## Step 34: DevRel Tools

Content creation:

• Ghost (blogging)
• Notion (documentation)
• Loom (video tutorials)
• OBS Studio (screen recording)

Community:

• Discord (community platform)
• Discourse (forums)
• Orbit (community analytics)
• Common Room (community intelligence)

Events:

• Bevy (event management)
• Hopin (virtual events)