specialized-roles-skill

What this skill does

# Specialized Roles & Tools Skill

Complete guide to career paths beyond traditional software engineering.

## Quick Start

### Choose Your Specialization

```
Product Manager ──────→ Product Strategy
Engineering Manager ──→ Technical Leadership
DevRel ────────────────→ Community & Advocacy
Technical Writer ──────→ Documentation
QA Engineer ───────────→ Quality & Testing
Blockchain Developer ──→ Web3 & Crypto
Game Developer ────────→ Game Engines
Cybersecurity ─────────→ Penetration Testing
```

---

## Product Management

### **Core Responsibilities**

1. **Product Vision & Strategy**
   - Define product roadmap (12-24 months)
   - Set OKRs (Objectives & Key Results)
   - Competitive analysis
   - Market opportunity assessment

2. **Discovery & Requirements**
   ```
   User Research → Feature Prioritization → Specification
        ↓                ↓                        ↓
     Interviews     Importance/Effort    User Stories
     Surveys       Impact Matrix        PRDs (Product Requirement Docs)
   ```

3. **Metrics & Analytics**
   - Define success metrics (KPIs)
   - Track key metrics
   - Analyze user behavior
   - Data-driven decisions

   **Key Metrics Examples:**
   ```
   DAU (Daily Active Users)
   WAU (Weekly Active Users)
   Retention Rate = Users on Day 30 / Users on Day 1
   Churn Rate = 1 - Retention
   LTV (Lifetime Value) = Average revenue per user
   CAC (Customer Acquisition Cost)
   ```

4. **Cross-functional Leadership**
   - Work with engineers, designers, sales, marketing
   - Communicate vision clearly
   - Manage stakeholder expectations
   - Resolve conflicts

### **Product Manager Roadmap**

**Year 1:**
- Master product thinking
- Learn metrics and data analysis
- Build first roadmap
- Launch 2-3 features

**Year 2+:**
- Own product P&L
- Build and mentor team
- Strategic partnerships
- Company-wide influence

### **Tools**
- Figma/Miro (wireframing)
- Jira (project tracking)
- Amplitude/Mixpanel (analytics)
- Notion (documentation)

---

## Engineering Management

### **Core Responsibilities**

1. **Team Leadership**
   - Hire and onboard engineers
   - Conduct 1-on-1 meetings
   - Performance management
   - Career development

2. **Technical Oversight**
   - Architecture decisions
   - Code review standards
   - Technology choices
   - Technical debt management

3. **Delivery & Planning**
   - Sprint planning
   - Risk assessment
   - Timeline estimation
   - Release management

4. **Communication**
   - Team standup facilitation
   - Retrospectives
   - Executive updates
   - Cross-team collaboration

### **Engineering Manager Skills**

```
Technical Skills (30%):
- Deep product knowledge
- Architecture understanding
- Technology landscape
- Database/infrastructure basics

Management Skills (40%):
- Communication
- Conflict resolution
- Feedback delivery
- Team motivation

Business Skills (30%):
- P&L management
- Hiring metrics
- OKRs and strategy
- Roadmap planning
```

### **Coaching Framework (1-on-1s)**

```
1-on-1 Meeting Structure (30-60 minutes):
1. Personal check-in (5 min)
2. Last week recap (5 min)
3. Blockers/issues (10 min)
4. Goals and progress (10 min)
5. Development plan (5-10 min)
6. Feedback exchange (5 min)

Feedback Model (SBI):
Situation - "In the code review yesterday..."
Behavior - "You pushed back on the architecture without..."
Impact - "...which made the team feel unheard"
```

---

## Developer Relations (DevRel)

### **Core Responsibilities**

1. **Community Building**
   - Build online communities (Discord, Slack)
   - Organize meetups and conferences
   - Forum moderation
   - User support

2. **Content Creation**
   - Blog posts and tutorials
   - Video tutorials and livestreams
   - Code examples and samples
   - API documentation

3. **Advocacy & Marketing**
   - Conference speaking
   - Thought leadership
   - Developer marketing
   - Brand building

4. **Feedback Loop**
   - Collect developer feedback
   - Report to product team
   - Feature advocacy
   - Customer success stories

### **Content Types**

```
Educational:
- Getting started guides
- API documentation
- Code patterns
- Best practices

Promotional:
- Case studies
- Customer stories
- "Built with..." features
- Product announcements

Community:
- Forum participation
- Event organization
- Sponsorships
- Developer meetups
```

### **DevRel Metrics**
- Community growth (Discord, GitHub followers)
- Content engagement (views, shares, comments)
- Speaking opportunities
- Developer satisfaction (surveys)

---

## Technical Writing

### **Core Responsibilities**

1. **Documentation Types**
   ```
   API Docs → Complete endpoint reference
   Tutorials → Step-by-step guides
   Guides → In-depth topics
   FAQs → Common questions
   Troubleshooting → Problem solutions
   ```

2. **Writing Best Practices**
   - Clear, concise language
   - Active voice
   - Short sentences
   - Consistent formatting
   - Real code examples

   **Good Example:**
   ```
   ✓ Run `npm install` to install dependencies.
   ✓ Use the POST /users endpoint to create users.
   ✓ Save your API key in a secure location.

   ✗ Dependencies should be installed via npm.
   ✗ POST /users can be utilized for user creation.
   ✗ API keys should be kept in a secure manner.
   ```

3. **Tools**
   - Markdown
   - Sphinx (Python)
   - MkDocs
   - Docusaurus
   - ReadTheDocs
   - GitHub Pages

4. **Documentation Site Structure**
   ```
   /docs
   ├── Getting Started
   ├── API Reference
   ├── Guides
   │   ├── Authentication
   │   ├── Rate Limiting
   │   └── Error Handling
   ├── Examples
   └── Troubleshooting
   ```

### **Technical Writing Checklist**
- [ ] Audience clearly defined
- [ ] Jargon minimized
- [ ] Code examples functional
- [ ] Consistent terminology
- [ ] Proper formatting
- [ ] Up-to-date information
- [ ] Search-friendly
- [ ] Mobile-responsive

---

## Quality Assurance (QA)

### **Testing Types**

**Unit Testing:**
```python
import unittest

class TestCalculator(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

    def test_add_negative(self):
        self.assertEqual(add(-1, 5), 4)
```

**Integration Testing:**
```javascript
test('User registration flow', async () => {
  const response = await registerUser({
    email: '[email protected]',
    password: 'secure123'
  });
  expect(response.status).toBe(201);

  const loginResponse = await login({
    email: '[email protected]',
    password: 'secure123'
  });
  expect(loginResponse.user).toBeDefined();
});
```

**End-to-End Testing:**
```javascript
// Cypress
describe('Login flow', () => {
  it('should login successfully', () => {
    cy.visit('/login');
    cy.get('input[name="email"]').type('[email protected]');
    cy.get('input[name="password"]').type('password');
    cy.get('button[type="submit"]').click();
    cy.url().should('include', '/dashboard');
  });
});
```

**Performance Testing:**
```bash
# Load testing with artillery
artillery load-test config.yml

# Results show:
# - Response times
# - Error rates
# - Throughput
```

### **QA Checklist**
- [ ] Functional testing complete
- [ ] Edge cases tested
- [ ] Performance acceptable
- [ ] Security vulnerabilities checked
- [ ] Cross-browser compatible
- [ ] Mobile responsive
- [ ] Accessibility standards met
- [ ] Documentation accurate

---

## Blockchain Development

### **Blockchain Fundamentals**

```solidity
// Solidity (Ethereum smart contract language)
pragma solidity ^0.8.0;

contract SimpleToken {
    mapping(address => uint256) public balances;
    string public name = "SimpleToken";
    uint256 public totalSupply = 1000000;

    constructor() {
        balances[msg.sender] = totalSupply;
    }

    function transfer(address to, uint256 amount) public {
        require(balances[msg.sender] >= amount);
        balances[msg.sender] -= amount;
        balances[to] += amount;
    }

    function balance(address account) public view returns (uint256) {
        return balances[account];
    }
}
```

##