🚀 Microservice Extraction Challenge

A real-world technical challenge that mirrors the exact work our Middleware Architect will be doing - extracting tightly coupled services from our Django monolith while maintaining production standards.

📦 View Challenge Repository on GitHub

⏱️ Challenge Timeline

Candidates have flexibility in how they approach the timeline, but should plan for these phases:

📋
Phase 1: Analysis & Planning
Review provided Django monolith, identify coupling points, and design extraction strategy
30-45 min
🏗️
Phase 2: Core Implementation
Extract notification service, implement API endpoints, and set up independent deployment
2-2.5 hours
🔧
Phase 3: Integration Patterns
Implement circuit breaker, retry logic, or event-driven communication patterns
45-60 min
📝
Phase 4: Documentation & Testing
Complete README, migration plan, and ensure tests pass with >80% coverage
30-45 min

📋 Core Requirements

Extract the notifications service from a provided Django monolith into an independent, production-ready microservice.

🏗️ Service Architecture
Create clean service boundaries with proper separation of concerns. Implement API, core business logic, adapters, and event handling layers.
40% of evaluation
🔌 API Specification
Design RESTful endpoints for notifications, templates, and user preferences with OpenAPI documentation and proper validation.
20% of evaluation
🗃️ Data Migration
Plan zero-downtime migration strategy for moving notification data from monolith to microservice database.
20% of evaluation
🔄 Integration Patterns
Implement at least two resilience patterns: circuit breaker, retry with backoff, event-driven communication, or bulkhead pattern.
20% of evaluation

📦 Challenge Materials

Everything candidates need to complete the challenge successfully.

📋
Requirements Document
Complete technical specifications, API endpoints, and evaluation criteria
View Requirements
💻
Starter Code
Django monolith with notifications, identity, and payments apps for extraction
View Starter Code
📖
Evaluation Guide
Detailed scoring rubric and what evaluators will be looking for
View Guide
🚀
Complete Package
All materials in a single ZIP file for easy distribution
Clone Repository

📊 Evaluation Criteria

Candidates will be evaluated across these five key areas with specific weightings:

Criteria Weight Key Focus Areas Success Indicators
Code Quality
30% Clean code, SOLID principles, error handling, type hints Readable, maintainable code with proper abstractions
Architecture
25% Separation of concerns, dependency injection, scalability Clear service boundaries and extensible design
Testing
20% Unit tests >80% coverage, integration tests, mocks Comprehensive test suite with good coverage
Documentation
15% README, API docs, architecture decisions, migration plan Clear documentation that enables easy understanding
DevOps Readiness
10% Dockerfile, environment config, CI/CD readiness Production-ready deployment configuration

🎯 Extension Challenges (Optional)

For candidates who complete the core challenge quickly, these extensions demonstrate advanced capabilities:

⚡ Performance Optimization
Fix N+1 queries, implement caching, add database indexes, and provide benchmark comparisons.
+15 bonus points
🛡️ Resilience & Observability
Add health checks, graceful shutdown, metrics collection, and distributed tracing.
+15 bonus points
🔄 Advanced Event Streaming
Implement event sourcing with Kafka/RabbitMQ, including exactly-once semantics and event replay.
+20 bonus points

✅ Success Criteria

Minimum Requirements

  • Service runs locally without errors
  • All tests pass
  • API endpoints work correctly
  • Basic documentation provided
  • Docker setup functional

Strong Performance

  • >80% test coverage achieved
  • Clean architectural separation
  • Comprehensive documentation
  • 2+ integration patterns implemented
  • Production-ready considerations

Exceptional Work

  • Extension challenges completed
  • Performance optimizations
  • Advanced monitoring setup
  • Event-driven architecture
  • Innovation beyond requirements