🟡 Intermediate Issues

You've made a few contributions and you're ready for something more challenging. Intermediate issues require coding skills and understanding of the project's architecture.

What Makes an Issue "Intermediate"?

Intermediate issues typically include:

• 🔧 Real Coding Required - Actual feature implementation or bug fixes
• 📚 Some Context Needed - Understanding of the codebase structure
• 🧪 Testing Required - Writing or updating tests
• 🎯 Moderate Scope - Can be completed in a few days
• 💡 Problem-Solving - Requires thinking through solutions

Types of Intermediate Issues

🚀 Feature Implementation

What it involves:

• Adding new functionality
• Implementing requested features
• Enhancing existing features
• Integrating third-party services

Example Tasks:

• "Add dark mode toggle"
• "Implement search functionality"
• "Add export to PDF feature"
• "Integrate GitHub API"

Skills Needed:

• Proficiency in the project's language
• Understanding of the framework/library
• Ability to write clean, maintainable code
• Testing skills

🐛 Bug Fixes

What it involves:

• Debugging complex issues
• Fixing logic errors
• Resolving edge cases
• Performance improvements

Example Tasks:

• "Fix memory leak in data processing"
• "Resolve race condition in async function"
• "Fix incorrect calculation in algorithm"
• "Improve query performance"

Skills Needed:

• Debugging skills
• Understanding of the codebase
• Problem-solving abilities
• Testing and verification

🎨 UI/UX Improvements

What it involves:

• Implementing complex layouts
• Adding animations and transitions
• Improving user experience
• Responsive design implementation

Example Tasks:

• "Implement drag-and-drop interface"
• "Add loading animations"
• "Improve mobile responsiveness"
• "Create interactive dashboard"

Skills Needed:

• HTML, CSS, JavaScript
• Framework knowledge (React, Vue, etc.)
• Design principles
• Cross-browser testing

📊 Data & API Work

What it involves:

• Creating API endpoints
• Database schema changes
• Data migration
• API integration

Example Tasks:

• "Create REST API for user management"
• "Add pagination to API endpoints"
• "Implement caching layer"
• "Integrate external API"

Skills Needed:

• Backend development
• Database knowledge
• API design principles
• Security awareness

🧪 Testing & Quality

What it involves:

• Writing unit tests
• Integration testing
• End-to-end testing
• Code coverage improvement

Example Tasks:

• "Add unit tests for authentication module"
• "Implement E2E tests for checkout flow"
• "Increase code coverage to 80%"
• "Add integration tests for API"

Skills Needed:

• Testing frameworks
• Test-driven development
• Understanding of testing best practices
• Code quality awareness

How to Approach Intermediate Issues

Step 1: Understand the Codebase

Before starting:

• Clone the repository
• Read the architecture documentation
• Explore the code structure
• Run the project locally
• Understand the tech stack

Step 2: Analyze the Issue

Break down the problem:

• What needs to be changed?
• Where in the codebase?
• What are the dependencies?
• What could break?
• How to test it?

Step 3: Plan Your Approach

Create a mental roadmap:

1. Identify files to modify
2. Plan the implementation
3. Consider edge cases
4. Think about testing
5. Estimate time needed

Step 4: Implement Incrementally

Work in small steps:

• Make one change at a time
• Test frequently
• Commit logical chunks
• Keep changes focused
• Document as you go

Step 5: Test Thoroughly

Ensure quality:

• Write unit tests
• Test edge cases
• Check for regressions
• Test on different environments
• Get feedback early

💡 Best Practices

Code Quality

// ❌ Bad: Unclear, no error handling
function getData(id) {
  return fetch('/api/data/' + id).then(r => r.json());
}

// ✅ Good: Clear, with error handling
async function fetchDataById(id: string): Promise<Data> {
  try {
    const response = await fetch(`/api/data/${id}`);
    if (!response.ok) {
      throw new Error(`Failed to fetch data: ${response.statusText}`);
    }
    return await response.json();
  } catch (error) {
    console.error('Error fetching data:', error);
    throw error;
  }
}

Testing

// ✅ Good: Comprehensive test
describe('fetchDataById', () => {
  it('should fetch data successfully', async () => {
    const mockData = { id: '1', name: 'Test' };
    global.fetch = jest.fn(() =>
      Promise.resolve({
        ok: true,
        json: () => Promise.resolve(mockData),
      })
    );

    const result = await fetchDataById('1');
    expect(result).toEqual(mockData);
  });

  it('should handle errors gracefully', async () => {
    global.fetch = jest.fn(() =>
      Promise.resolve({
        ok: false,
        statusText: 'Not Found',
      })
    );

    await expect(fetchDataById('1')).rejects.toThrow();
  });
});

Documentation

/**
 * Fetches user data from the API
 * 
 * @param {string} userId - The unique identifier of the user
 * @returns {Promise<User>} The user object
 * @throws {Error} If the API request fails
 * 
 * @example
 * const user = await fetchUserData('123');
 * console.log(user.name);
 */
async function fetchUserData(userId) {
  // Implementation
}

🎯 Common Challenges

Challenge 1: Understanding Legacy Code

Problem: Codebase is complex and poorly documented

Solution:

• Start with the entry point
• Use debugger to trace execution
• Draw diagrams of data flow
• Ask maintainers for guidance
• Read related issues and PRs

Challenge 2: Scope Creep

Problem: Issue grows beyond original scope

Solution:

• Stick to the original requirements
• Discuss scope changes with maintainers
• Create separate issues for additional work
• Keep PRs focused and reviewable

Challenge 3: Merge Conflicts

Problem: Your branch conflicts with main

Solution:

# Keep your branch updated
git fetch origin
git rebase origin/main

# Resolve conflicts
# Edit conflicting files
git add .
git rebase --continue

Challenge 4: Performance Issues

Problem: Implementation is slow or inefficient

Solution:

• Profile your code
• Identify bottlenecks
• Optimize algorithms
• Use caching where appropriate
• Consider lazy loading

📈 Level Up Your Skills

Learn These Concepts

1. Design Patterns - Common solutions to recurring problems
2. SOLID Principles - Object-oriented design principles
3. Clean Code - Writing readable, maintainable code
4. Testing Strategies - Unit, integration, E2E testing
5. Git Workflows - Branching strategies, rebasing, etc.
6. Code Review - Giving and receiving feedback
7. Performance Optimization - Making code faster and more efficient

Recommended Resources

• Books:

  • "Clean Code" by Robert C. Martin
  • "Refactoring" by Martin Fowler
  • "Design Patterns" by Gang of Four

• Online:

  • Refactoring Guru
  • JavaScript.info
  • MDN Web Docs

🚀 Ready for the Challenge?

Quick Links

• Browse All Intermediate Issues
• Advanced Issues
• Beginner Issues
• Tutorials

💪 You're Growing!

Intermediate issues are where you really start to grow as a developer. You'll:

• Deepen Your Skills - Learn advanced concepts
• Build Confidence - Tackle complex problems
• Gain Recognition - Become a valued contributor
• Expand Network - Connect with experienced developers
• Prepare for Advanced - Ready for the next level