Sistema 1: E-commerce Microservices Platform
Objetivos
Aprender conceitos de backend, frontend e DevOps desenvolvendo um sistema full-stack.
- Microservices, containerization, REST APIs, SQL/NoSQL databases, message queues, system design.
- Github Actions, Project Management
Descrição técnica do projeto
Overview: Build a small e-commerce platform with services such as:
- Product Catalog: Uses a NoSQL database (e.g., MongoDB) to store product information.
- Order Management: Uses SQL (e.g., PostgreSQL) to store orders and transactions.
- User Service: Handles authentication (JWT) and user profiles.
- Notification Service: Sends emails or SMS using message queues (e.g., RabbitMQ or Kafka).
Tasks for the mentee:
- Deploy microservices using Docker.
- Set up message queues to notify users of successful orders.
- Integrate SQL for order management and NoSQL for the product catalog.
- Introduce API gateways for communication between services.
Semana 1
Tarefa
- Implementar serviço de produtos (API em Django Rest Framework, CRUD, banco de dados NoSQL)
Teoria
- SQL vs NoSQL
- API Gateway vs Load Balancer
- A simple guide to configure Nginx as an API Gateway
- Docker curriculum
- Microsserviços Prontos Para a Produção: Construindo Sistemas Padronizados em uma Organização de Engenharia de Software
Semana 2
Tarefa
- Acessar o console do MongoDB localmente e brincar fazendo queries.
- Implementar frontend de produtos (projeto React, CRUD usando a api criada na primeira semana)
- Usar docker para toda a aplicação (container para o serviço de produtos, pro frontend, pro banco de dados)
Teoria
- CAP Theorem Simplified
- ACID Databases
- ACID vs BASE
- Normalização em banco de dados
- Dockerfile vs. Docker Compose: What You Should Know
- 10 Core Concepts You Need to Know About React
- Microsserviços Prontos Para a Produção: Construindo Sistemas Padronizados em uma Organização de Engenharia de Software
Semana 3
Tarefa
- Acessar o console do MongoDB localmente e brincar fazendo queries.
- Usar docker para toda a aplicação (container para o serviço de produtos, pro frontend, pro banco de dados)
- Criar (backend e frontend) order management service
- Com docker, backend em FastAPI, PostgreSQL como banco de dados.
Teoria
- Database Types
- 7 must-know strategies to scale your database
- Locust load testing
- Microsserviços Prontos Para a Produção: Construindo Sistemas Padronizados em uma Organização de Engenharia de Software
Semana 4
Tarefa
- Fazer load-testing da aplicação localmente
- Usar docker para toda a aplicação (container para o serviço de produtos, pro frontend, pro banco de dados)
Teoria
- Selecting a React Component Library, the Strategic Way
- What I Wish Someone Told Me About Postgres
- How Amazon Scaled E-commerce Shopping Cart Data Infrastructure
- Everything You NEED to KNOW About Web Applications
Semana 5
Tarefa
- Consertar docker
- Montar layout do site (usando alguma component library do react e/ou tailwind)
Teoria
- From laid off to hired: A Software Engineer’s guide
- Good software development habits
- 7 Mindsets That Are Slowing Down Your Career Growth
Sistema 2: AWS - Site estático
Semana 6
Tarefa
- Deployar um site estático na AWS
Teoria
Sistema 3: Task Management Application
High-Level Overview
This project is a task management application designed to allow users to manage their daily tasks with features like adding, updating, deleting, and categorizing tasks. Each task can have a title, description, priority, deadline, and tags (e.g., “work,” “personal”). Users will also be able to mark tasks as completed and filter tasks by category, deadline, or priority.
The system should be implemented using Python for the backend, React for the frontend, and deployed to AWS. It will focus on SOLID principles, proper API design, NoSQL database usage, and design patterns for maintainable and scalable code.
Core Functionalities
User Authentication
- Register, login, and logout features using AWS Cognito.
- Secure the API with authentication tokens (JWT).
Task Management
- Add new tasks with details (title, description, priority, deadline, tags).
- Update or delete existing tasks.
- Mark tasks as completed.
- List tasks with filtering and sorting options (e.g., by priority, deadline, or tags).
Tags Management
- Allow users to define and assign tags for better categorization.
Task Insights
- Provide a summary of task statistics, such as the number of completed tasks and pending tasks grouped by priority or deadline.
High-Level Architecture
Frontend (React)
- UI Framework: Use Material-UI or Tailwind CSS for styling.
- State Management: Use Context API or Redux for state management.
Features:
- A dashboard for managing tasks.
- Forms for adding/updating tasks.
- Filtering and sorting options for tasks.
- Authentication pages (login/register).
Backend (Python)
- Framework: Use FastAPI for a clean and simple API.
- Database: Use MongoDB (hosted on AWS DocumentDB) for storing tasks, users, and tags.
Features:
- RESTful APIs for CRUD operations.
- Input validation and error handling.
- Modularized codebase adhering to SOLID principles.
AWS Deployment
- Backend: Deploy as a containerized service using AWS ECS.
- Frontend: Host the React app on AWS S3 and use CloudFront for CDN.
- Database: Use AWS DocumentDB (MongoDB).
- Authentication: Manage using AWS Cognito.
Focus on SOLID Principles
- Single Responsibility: Separate concerns into services: authentication, task management, and tags.
- Open/Closed Principle: Design services and models to allow extensions without modifying the existing codebase.
- Liskov Substitution: Use interfaces or abstract classes where necessary (e.g., for repository pattern).
- Interface Segregation: Keep APIs focused on single responsibilities (e.g., task endpoints don’t handle user-related operations).
- Dependency Inversion: Use dependency injection for database access, allowing for easier testing and mocking.
Design Patterns
- Repository Pattern: Abstract MongoDB operations into a repository to separate database logic from business logic.
- Factory Pattern: Use factories for creating tasks or tags with default values and validations.
- Strategy Pattern: Implement sorting and filtering using interchangeable strategies.
AWS Services
- AWS ECS: Host the Python backend as a containerized service.
- AWS S3 + CloudFront: Serve the React frontend.
- AWS Cognito: Manage user authentication.
- AWS DocumentDB: Store tasks and tags in a MongoDB-compatible NoSQL database.
- AWS CloudWatch: Monitor logs and system performance.
- AWS IAM: Secure access to AWS resources.
Semana 7
Teoria
- Linux Commands Every DevOps Engineer Must Know
- Big O Notation
- SOLID: The First 5 Principles of Object Oriented Design
- Design Patterns in Python
Tarefa
Task 1: Project Setup Goal: Set up the foundational structure for both the backend and frontend projects.
Backend (Python):
Initialize a Python project using FastAPI or Flask. Set up a virtual environment and install essential packages (fastapi, uvicorn, pymongo). Create a basic API endpoint (/health) to verify the backend is running. Write Dockerfile and configure for containerization.
Frontend (React):
Initialize a React project using create-react-app. Set up project structure (components, pages, utils). Create a basic homepage with a “Hello, World” message.
Testing:
Verify the frontend connects to the backend API.
Semana 8
Teoria
- How To Build Web Apps using V0 + Claude AI + Cursor AI
- How I built a REAL app using Figma AI in 48 hrs! (ENTIRE UX/UI Process)
Tarefa
Task 2: User Authentication Goal: Implement user registration, login, and authentication using AWS Cognito.
- Backend:
- Set up AWS Cognito and configure a user pool.
- Create APIs for user registration and login.
- Implement token validation middleware for securing APIs.
- Frontend:
- Create React components for login and registration forms.
- Integrate Cognito authentication using AWS Amplify or
amazon-cognito-identity-js
. - Display error messages for failed logins.
- Testing:
- Verify user registration and login flows locally and ensure tokens are passed to secure backend APIs.
Entrevista Técnica
Techical questions
1. “Explain how you would implement a rate limiter using the a design pattern in Python. How would this compare to other patterns you might use for the same problem?”
- How the Decorator pattern allows for separation of concerns
- Thread safety considerations
- Non-intrusive
- Reusable
- Composable with other decorators
from functools import wraps
from time import time
from collections import defaultdict
import threading
def rate_limit(max_requests: int, window_seconds: int):
"""
Rate limiting decorator that allows max_requests in window_seconds
"""
lock = threading.Lock()
requests = defaultdict(list) # key: ip, value: list of timestamps
def decorator(f):
@wraps(f)
def wrapped(request, *args, **kwargs):
ip = request.client_ip # assuming request has client_ip attribute
with lock:
# Clean old requests
current = time()
requests[ip] = [req_time for req_time in requests[ip]
if current - req_time <= window_seconds]
# Check if rate limit exceeded
if len(requests[ip]) >= max_requests:
raise RateLimitExceeded("Too many requests")
# Add new request timestamp
requests[ip].append(current)
return f(request, *args, **kwargs)
return wrapped
return decorator
# Usage example
@rate_limit(max_requests=100, window_seconds=60)
def some_api_endpoint(request):
return {"status": "success"}
2. “You’re designing a social media platform’s backend. Walk me through how you would choose between SQL and NoSQL databases for different components of the system, and what specific database types you would consider.”
- NoSQL for relationship between users (graph database)
- NoSQL (e.g., MongoDB) for posts/content due to flexible schema requirements and high write throughput
- Redis for caching and session management
- Specific examples of when schema flexibility is worth trading off consistency
- Discussion of read/write patterns and scaling considerations
3. “Explain the CAP theorem and provide a real-world example where you had to make tradeoffs between consistency, availability, and partition tolerance.”
- Clear explanation that you can only guarantee two out of three properties
- Explanation that partition tolerance isn’t optional in distributed systems
- Real example like choosing eventual consistency for news feed updates
- Understanding that CAP theorem tradeoffs exist on a spectrum
- Discussion of techniques like read-repair or vector clocks
4. “You have a distributed system processing financial transactions. How would you ensure ACID properties are maintained, and what are the performance implications?”
- Detailed explanation of Atomicity, Consistency, Isolation, and Durability
- Discussion of distributed transactions and two-phase commit
- Performance implications of different isolation levels
- Mention of eventual consistency as an alternative
- Concrete examples of when to relax ACID properties
5. “How would you implement authentication and authorization in a RESTful API? Walk through the security considerations.”
- JWT structure and usage
- OAuth 2.0 flows
- Refresh token strategies
- CORS configuration
- Rate limiting
- Password hashing
- Session management
- Common security vulnerabilities
6. “You notice that your API endpoints are becoming slower over time. Walk me through your debugging process and potential solutions.”
- Systematic approach to identifying bottlenecks
- Tools they would use (APM, profilers, logs)
- Database query optimization
- Caching strategies
- Connection pooling
- N+1 query problems
- Resource scaling
- Monitoring and alerting setup
Behavioral Questions:
1. “Tell me about a time when you had to make a significant technical decision that others disagreed with. How did you handle it?”
- Clear problem statement
- Data-driven decision making process
- How they built consensus
- Implementation challenges
- Lessons learned and outcomes
2. “Describe a situation where you had to deal with technical debt. How did you approach it?”
- How they identified and measured the debt
- Strategy for addressing it incrementally
- How they convinced stakeholders
- Balance between new features and maintenance
- Long-term impact of their approach
3. “Tell me about a time when you had to mentor someone who was struggling. What was your approach?”
- Assessment of the root causes
- Structured approach to improvement
- Specific examples of interventions
- Measuring progress
- Long-term outcomes
4. “Describe a project that failed or had significant setbacks. What did you learn from it?”
- Honest assessment of what went wrong
- Their role in the situation
- How they adapted
- Specific learnings
- How they applied these lessons later
Referenced in
- No backlinks found