Jesse's Notes

Shift Left

3 min read

Shift Left is the practice of moving quality activities earlier in the software development lifecycle.

Core Concept

Instead of finding and fixing defects late in the development process (or after release), catch them as early as possible - ideally before code is even written.

The Cost of Defects Over Time

Bugs found and fixed:

  • During design/planning: 1x cost
  • During development: 5x cost
  • During testing: 10x cost
  • In production: 100x+ cost

The earlier you find issues, the cheaper and easier they are to fix.

Shift Left Practices

1. Requirements and Design

  • Specification by Example: Define expected behavior as examples before coding
  • Threat Modeling: Identify security issues in design phase
  • Architecture Reviews: Validate design decisions early

2. Development Phase

  • Test-Driven Development (TDD): Write tests before code
  • Unit Testing: Test components as they’re built
  • Static Analysis: Automated code quality checks in IDE and pre-commit hooks
  • Pair Programming: Real-time code review

3. Continuous Integration

  • Automated Testing: Run full test suite on every commit
  • Build Validation: Catch integration issues immediately
  • Security Scanning: Automated dependency and vulnerability scanning
  • Code Quality Gates: Enforce standards before merge

4. Pre-Production

  • Integration Testing: Test component interactions early
  • Performance Testing: Catch scalability issues before production
  • Accessibility Testing: Ensure compliance early

Shift Left Testing Pyramid

    /\          E2E Tests (Few)
   /  \         - Expensive
  /____\        - Slow
 /      \       - Brittle
/________\
Integration Tests (Some)
- Moderate cost
- Moderate speed

Unit Tests (Many)
- Cheap
- Fast
- Stable

Benefits

Cost Reduction

  • Fix issues when they’re cheapest to address
  • Reduce rework and waste

Faster Delivery

  • Fewer blockers late in development
  • Reduced time in testing/QA phases
  • Confident deployments

Higher Quality

  • Prevent defects rather than detect them
  • Better understanding of requirements
  • Continuous quality validation

Implementation Strategies

Developer-Centric Quality

// TDD: Test first
[Test]
public void Order_WithVolumeDiscount_AppliesCorrectPercentage()
{
    var order = new Order();
    order.AddItem(product, quantity: 100);
 
    decimal total = order.CalculateTotal();
 
    Assert.AreEqual(900m, total); // 10% discount applied
}
 
// Then implement
public class Order
{
    public decimal CalculateTotal()
    {
        decimal total = _items.Sum(i => i.Subtotal);
        if (total > 100)
            total *= 0.9m;
        return total;
    }
}

Automated Quality Gates

# Pre-commit hooks
pre-commit:
  - lint
  - unit-tests
  - security-scan
 
# CI pipeline
on-pull-request:
  - build
  - unit-tests
  - integration-tests
  - code-coverage-check
  - security-scan
  - accessibility-tests

Fast Feedback Loops

  • IDE Integration: Real-time linting and type checking
  • Pre-commit Hooks: Catch issues before they’re committed
  • Fast CI Builds: Sub-10-minute feedback cycles
  • Deployment Previews: See changes in production-like environments

Challenges

  • Requires Cultural Change: Developers must embrace quality ownership
  • Initial Investment: Setting up automation and tooling
  • Learning Curve: Teams need training on new practices
  • Discipline Required: Easy to skip when under pressure

Resources

Graph View

Backlinks