# Dev Weekends

## Docs

- [Advanced Prompting Techniques](https://resources.devweekends.com/ai-engineering/advanced-prompting.md): Master Chain-of-Thought, Tree-of-Thought, ReAct, and other advanced prompting strategies
- [Advanced RAG Techniques](https://resources.devweekends.com/ai-engineering/advanced-rag.md): Master HyDE, multi-query retrieval, parent document retrieval, and other advanced RAG patterns
- [Agentic Architecture](https://resources.devweekends.com/ai-engineering/agentic-architecture.md): Design patterns for building reliable multi-agent AI systems
- [AI Agents](https://resources.devweekends.com/ai-engineering/agents.md): Build production autonomous agents with tools, memory, and multi-step reasoning
- [AI Security & Guardrails](https://resources.devweekends.com/ai-engineering/ai-security-guardrails.md): Protect LLM applications from attacks and ensure safe outputs
- [Anthropic Claude API](https://resources.devweekends.com/ai-engineering/anthropic-api.md): Master the Anthropic Claude API with messages, system prompts, and advanced features
- [API Design for AI Applications](https://resources.devweekends.com/ai-engineering/api-design.md): REST endpoints, async patterns, webhooks, and rate limiting for LLM APIs
- [Async Patterns for LLMs](https://resources.devweekends.com/ai-engineering/async-patterns.md): Master concurrent LLM requests with async patterns, rate limiting, and backoff strategies
- [Batch Processing & Rate Limiting](https://resources.devweekends.com/ai-engineering/batch-processing.md): Process large volumes of LLM requests efficiently with batching and rate limiting
- [Capstone Project](https://resources.devweekends.com/ai-engineering/capstone-project.md): Build a production AI SaaS from scratch—your portfolio piece
- [Chatbot Design Patterns](https://resources.devweekends.com/ai-engineering/chatbot-patterns.md): Build production conversational AI with state management, slot filling, and multi-turn dialogue
- [Text Classification](https://resources.devweekends.com/ai-engineering/classification.md): Build zero-shot, few-shot, and fine-tuned classification systems with LLMs
- [Context Window Management](https://resources.devweekends.com/ai-engineering/context-management.md): Token counting, context compression, sliding windows, and summarization strategies
- [Cost Optimization & Token Management](https://resources.devweekends.com/ai-engineering/cost-optimization.md): Reduce LLM costs and optimize token usage in production
- [Databases & ORM Crash Course](https://resources.devweekends.com/ai-engineering/databases-crash-course.md): PostgreSQL, SQLAlchemy, and async database patterns for AI applications
- [Deployment & Scaling](https://resources.devweekends.com/ai-engineering/deployment-scaling.md): Deploy AI applications to production with reliability, performance, and cost efficiency
- [Document Processing](https://resources.devweekends.com/ai-engineering/document-processing.md): Learn PDF extraction, text chunking strategies, and document loaders for RAG applications
- [DSPy Framework](https://resources.devweekends.com/ai-engineering/dspy.md): Programming LLMs, not prompting: Declarative AI with Stanford's DSPy
- [Embeddings Deep Dive](https://resources.devweekends.com/ai-engineering/embeddings.md): Master embedding models, similarity search, and vector operations
- [Error Handling & Resilience](https://resources.devweekends.com/ai-engineering/error-handling.md): Production error handling, retry strategies, and resilience patterns for LLM applications
- [Evaluation & Testing](https://resources.devweekends.com/ai-engineering/evaluation-testing.md): Build reliable AI systems with comprehensive evaluation, testing, and monitoring
- [FastAPI Crash Course](https://resources.devweekends.com/ai-engineering/fastapi-crash-course.md): Build production-ready AI APIs with FastAPI
- [Fine-Tuning LLMs](https://resources.devweekends.com/ai-engineering/fine-tuning.md): Customize models for your specific use case with fine-tuning and PEFT techniques
- [Function Calling Deep Dive](https://resources.devweekends.com/ai-engineering/function-calling.md): Advanced function calling patterns including parallel execution, validation, and error handling
- [Image Generation](https://resources.devweekends.com/ai-engineering/image-generation.md): Learn DALL-E, image editing, and AI image generation patterns for production applications
- [Knowledge Graphs with LLMs](https://resources.devweekends.com/ai-engineering/knowledge-graphs.md): Build knowledge graphs with entity extraction, relationship mining, and GraphRAG patterns
- [LangChain](https://resources.devweekends.com/ai-engineering/langchain.md): Build production AI applications with chains, prompts, memory, and tools
- [LangGraph](https://resources.devweekends.com/ai-engineering/langgraph.md): Build complex agent workflows with state machines and conditional logic
- [LLM Caching](https://resources.devweekends.com/ai-engineering/llm-caching.md): Reduce costs and latency with intelligent caching strategies
- [LLM Fallbacks & Model Routing](https://resources.devweekends.com/ai-engineering/llm-fallbacks.md): Multi-provider fallback chains, model routing, and degradation strategies
- [LLM Fundamentals](https://resources.devweekends.com/ai-engineering/llm-fundamentals.md): Deep dive into how LLMs work—tokenization, attention, inference, and cost optimization
- [LLM Memory Systems](https://resources.devweekends.com/ai-engineering/llm-memory-systems.md): Implement short-term and long-term memory for AI agents
- [LLM Orchestration](https://resources.devweekends.com/ai-engineering/llm-orchestration.md): Unified APIs, provider abstraction, and request routing with LiteLLM
- [Testing LLM Applications](https://resources.devweekends.com/ai-engineering/llm-testing.md): Unit testing, integration testing, mocking LLMs, and test fixtures for AI applications
- [Model Context Protocol (MCP)](https://resources.devweekends.com/ai-engineering/mcp.md): Connect AI models to external tools and data sources with the MCP standard
- [Model Comparison](https://resources.devweekends.com/ai-engineering/model-comparison.md): Learn benchmark frameworks, evaluation metrics, and model selection criteria for LLM applications
- [Model Optimization](https://resources.devweekends.com/ai-engineering/model-optimization.md): Optimize LLM inference with quantization, batching, and serving frameworks
- [Multi-Agent Design Patterns](https://resources.devweekends.com/ai-engineering/multi-agent-patterns.md): Build sophisticated multi-agent systems with proven architectural patterns
- [Multimodal AI](https://resources.devweekends.com/ai-engineering/multimodal-ai.md): Build AI systems with vision, audio, and real-time voice capabilities
- [AI Observability & Monitoring](https://resources.devweekends.com/ai-engineering/observability-monitoring.md): Monitor, debug, and optimize LLM applications in production
- [Open Source & Local LLMs](https://resources.devweekends.com/ai-engineering/open-source-llms.md): Deploy and use open-source LLMs locally with Ollama, vLLM, and cloud alternatives
- [OpenAI API](https://resources.devweekends.com/ai-engineering/openai-api.md): Master the OpenAI API: chat completions, function calling, streaming, and structured outputs
- [Output Validation](https://resources.devweekends.com/ai-engineering/output-validation.md): Learn to validate and parse LLM outputs with Instructor, Guardrails, and custom strategies
- [AI Engineering](https://resources.devweekends.com/ai-engineering/overview.md): Build production-ready AI applications with Python, LLMs, agents, and modern AI infrastructure
- [Production Logging & Debugging](https://resources.devweekends.com/ai-engineering/production-logging.md): Structured logging, request tracing, audit logs, and debugging strategies for LLM applications
- [Prompt Engineering](https://resources.devweekends.com/ai-engineering/prompt-engineering.md): Master the art and science of crafting prompts that get reliable, high-quality outputs
- [Prompt Management & Versioning](https://resources.devweekends.com/ai-engineering/prompt-management.md): Version control, A/B testing, and lifecycle management for prompts
- [Python Crash Course](https://resources.devweekends.com/ai-engineering/python-crash-course.md): Essential Python for AI Engineers - from basics to advanced patterns
- [RAG Systems](https://resources.devweekends.com/ai-engineering/rag.md): Build production Retrieval-Augmented Generation pipelines with advanced techniques
- [Types of RAG](https://resources.devweekends.com/ai-engineering/rag-types.md): Master different RAG architectures from basic retrieval to advanced agentic and graph-based systems
- [Realtime AI Applications](https://resources.devweekends.com/ai-engineering/realtime-ai.md): Build low-latency AI applications with WebSockets, streaming, and the OpenAI Realtime API
- [Semantic Routing](https://resources.devweekends.com/ai-engineering/semantic-routing.md): Learn intent classification, query routing, and model selection for efficient LLM applications
- [Semantic Search & Retrieval](https://resources.devweekends.com/ai-engineering/semantic-search.md): Hybrid search, reranking, BM25, and advanced retrieval techniques
- [AI Streaming](https://resources.devweekends.com/ai-engineering/streaming.md): Build responsive AI applications with streaming responses
- [Structured Outputs](https://resources.devweekends.com/ai-engineering/structured-outputs.md): Get reliable JSON and typed responses from LLMs every time
- [Summarization Systems](https://resources.devweekends.com/ai-engineering/summarization.md): Build extractive and abstractive summarization systems for documents, meetings, and content
- [Synthetic Data Generation](https://resources.devweekends.com/ai-engineering/synthetic-data.md): Generate high-quality training data, augment datasets, and create test fixtures with LLMs
- [Tool Calling & Function Calling](https://resources.devweekends.com/ai-engineering/tool-calling.md): Give LLMs the ability to call functions, APIs, and external tools
- [Vector Databases](https://resources.devweekends.com/ai-engineering/vector-databases.md): Store and search embeddings at scale with pgvector, Pinecone, and production patterns
- [Voice and Audio AI](https://resources.devweekends.com/ai-engineering/voice-audio.md): Build voice applications with Whisper, text-to-speech, and real-time audio processing
- [Case Study: Serverless URL Shortener](https://resources.devweekends.com/aws/case-study-serverless.md): Build a production-ready serverless application with Lambda, API Gateway, and DynamoDB
- [CDN & Edge Services](https://resources.devweekends.com/aws/cdn-edge.md): Master CloudFront, Global Accelerator, and edge computing for global performance
- [AWS CloudTrail](https://resources.devweekends.com/aws/cloudtrail.md): API logging and auditing for governance, compliance, and operational troubleshooting
- [Amazon CloudWatch](https://resources.devweekends.com/aws/cloudwatch.md): Master CloudWatch metrics, logs, alarms, dashboards, Log Insights, and operational monitoring
- [Compute Services](https://resources.devweekends.com/aws/compute.md): Master EC2, Lambda, ECS, EKS, and Auto Scaling for any workload
- [AWS Config](https://resources.devweekends.com/aws/config.md): Configuration compliance, change tracking, and automated remediation
- [Containers & Microservices](https://resources.devweekends.com/aws/containers.md): Master ECS, EKS, Fargate, and microservices patterns on AWS
- [Core Concepts](https://resources.devweekends.com/aws/core-concepts.md): AWS global infrastructure, regions, pricing, and fundamental concepts every cloud professional must know
- [DevOps & CI/CD](https://resources.devweekends.com/aws/devops-cicd.md): Master AWS CodePipeline, CloudFormation, CDK, and infrastructure automation
- [Amazon DynamoDB](https://resources.devweekends.com/aws/dynamodb.md): Master DynamoDB data modeling, capacity modes, GSIs, LSIs, transactions, and performance optimization
- [AWS GuardDuty](https://resources.devweekends.com/aws/guardduty.md): Intelligent threat detection service for protecting your AWS accounts and workloads
- [AWS Inspector](https://resources.devweekends.com/aws/inspector.md): Automated security assessment service for vulnerabilities and security best practices
- [AWS Lambda](https://resources.devweekends.com/aws/lambda.md): Master serverless compute with Lambda execution model, triggers, layers, optimization, and production patterns
- [Messaging & Integration](https://resources.devweekends.com/aws/messaging.md): Master SQS, SNS, EventBridge, and event-driven architecture patterns
- [Networking](https://resources.devweekends.com/aws/networking.md): Master VPC, subnets, security groups, load balancers, and network architecture
- [Observability & Monitoring](https://resources.devweekends.com/aws/observability.md): Master CloudWatch, X-Ray, CloudTrail, and AWS monitoring best practices
- [AWS Cloud Mastery](https://resources.devweekends.com/aws/overview.md): The complete AWS course for Solutions Architects, DevOps Engineers, and Cloud Professionals
- [AWS SAM](https://resources.devweekends.com/aws/sam.md): Build, test, and deploy serverless applications with the Serverless Application Model
- [Security & IAM](https://resources.devweekends.com/aws/security.md): Master IAM, encryption, KMS, security services, and AWS security best practices
- [AWS Security Hub](https://resources.devweekends.com/aws/security-hub.md): Centralized security posture management and compliance monitoring
- [AWS Shield](https://resources.devweekends.com/aws/shield.md): Managed DDoS protection service for AWS applications
- [AWS Step Functions](https://resources.devweekends.com/aws/step-functions.md): Master serverless workflow orchestration with state machines
- [Storage & Databases](https://resources.devweekends.com/aws/storage-databases.md): Master S3, EBS, EFS, RDS, DynamoDB, and ElastiCache
- [AWS WAF (Web Application Firewall)](https://resources.devweekends.com/aws/waf.md): Protect web applications from common web exploits and bot attacks
- [Well-Architected Framework](https://resources.devweekends.com/aws/well-architected.md): Master the 6 pillars for building reliable, secure, and efficient AWS systems
- [AWS X-Ray](https://resources.devweekends.com/aws/xray.md): Master distributed tracing with X-Ray for debugging and performance analysis
- [Example – Multi‑Vendor E‑commerce](https://resources.devweekends.com/case-studies/example-multi-vendor.md): A reference case study structure for a full MERN marketplace
- [Case Study Guide](https://resources.devweekends.com/case-studies/guide.md): Structure, content checklist, and rubric to write your case study
- [Case Studies](https://resources.devweekends.com/case-studies/overview.md): How to write an excellent engineering case study for DevWeekends
- [Case Study Template](https://resources.devweekends.com/case-studies/template.md): Copy this MDX and replace placeholders to create your case study
- [Angular Master Course](https://resources.devweekends.com/courses/angular-crash-course/00-overview.md): The complete Angular course from fundamentals to production-ready applications with modern best practices
- [01. Introduction & Setup](https://resources.devweekends.com/courses/angular-crash-course/01-introduction.md): Get started with Angular CLI, understand project structure, and build your first application
- [02. Components & Templates](https://resources.devweekends.com/courses/angular-crash-course/02-components.md): Master Angular component architecture, data binding, inputs/outputs, and lifecycle hooks
- [03. Directives & Pipes](https://resources.devweekends.com/courses/angular-crash-course/03-directives-pipes.md): Master built-in directives, create custom directives, and transform data with pipes
- [04. Services & Dependency Injection](https://resources.devweekends.com/courses/angular-crash-course/04-services-di.md): Master Angular's powerful DI system, create injectable services, and understand provider configurations
- [05. Angular Signals](https://resources.devweekends.com/courses/angular-crash-course/05-signals.md): Master Angular's modern reactive primitive for fine-grained reactivity and optimal performance
- [06. Routing & Navigation](https://resources.devweekends.com/courses/angular-crash-course/06-routing.md): Build multi-page applications with Angular Router, lazy loading, guards, and resolvers
- [07. Angular Forms](https://resources.devweekends.com/courses/angular-crash-course/07-forms.md): Master template-driven and reactive forms for robust user input handling and validation
- [08. HTTP Client & RxJS](https://resources.devweekends.com/courses/angular-crash-course/08-http-rxjs.md): Connect to APIs with HttpClient and master reactive programming with RxJS observables
- [09. RxJS Deep Dive](https://resources.devweekends.com/courses/angular-crash-course/09-rxjs.md): Master advanced RxJS patterns, operators, and reactive programming concepts
- [10. Change Detection & Performance](https://resources.devweekends.com/courses/angular-crash-course/10-change-detection.md): Master Angular's change detection mechanism and optimize application performance
- [11. Testing in Angular](https://resources.devweekends.com/courses/angular-crash-course/11-testing.md): Master unit testing, component testing, and end-to-end testing for Angular applications
- [12. Advanced Patterns](https://resources.devweekends.com/courses/angular-crash-course/12-advanced-patterns.md): Master advanced architectural patterns for building scalable Angular applications
- [13. Server-Side Rendering](https://resources.devweekends.com/courses/angular-crash-course/13-ssr.md): Master Angular Universal for SSR, hydration, and improved SEO and performance
- [14. Security Best Practices](https://resources.devweekends.com/courses/angular-crash-course/14-security.md): Protect your Angular application with security best practices and defense strategies
- [15. Capstone Project](https://resources.devweekends.com/courses/angular-crash-course/15-capstone.md): Build a complete full-stack Angular application applying all learned concepts
- [16. Standalone Components Deep Dive](https://resources.devweekends.com/courses/angular-crash-course/16-standalone.md): Master Angular's standalone components architecture for modern, modular applications
- [17. NgRx State Management](https://resources.devweekends.com/courses/angular-crash-course/17-ngrx.md): Master reactive state management with NgRx Store, Effects, Selectors, and Entity
- [18. Angular Animations](https://resources.devweekends.com/courses/angular-crash-course/18-animations.md): Create fluid, performant animations using Angular's animation system
- [19. Internationalization (i18n)](https://resources.devweekends.com/courses/angular-crash-course/19-i18n.md): Build multi-language Angular applications with i18n and localization best practices
- [20. Accessibility (a11y)](https://resources.devweekends.com/courses/angular-crash-course/20-accessibility.md): Build inclusive Angular applications that work for everyone
- [21. Angular Material & CDK](https://resources.devweekends.com/courses/angular-crash-course/21-material.md): Build professional UIs with Angular Material components and CDK primitives
- [22. PWA & Service Workers](https://resources.devweekends.com/courses/angular-crash-course/22-pwa.md): Build offline-capable Progressive Web Apps with Angular
- [23. Deployment & CI/CD](https://resources.devweekends.com/courses/angular-crash-course/23-deployment.md): Deploy Angular applications with modern CI/CD pipelines and infrastructure
- [24. Micro-frontends with Module Federation](https://resources.devweekends.com/courses/angular-crash-course/24-micro-frontends.md): Build scalable micro-frontend architectures using Webpack Module Federation
- [25. Nx Monorepo](https://resources.devweekends.com/courses/angular-crash-course/25-nx-monorepo.md): Scale Angular applications with Nx monorepo architecture and tooling
- [26. Performance Optimization](https://resources.devweekends.com/courses/angular-crash-course/26-performance.md): Advanced performance techniques for Angular applications
- [27. Content Projection](https://resources.devweekends.com/courses/angular-crash-course/27-content-projection.md): Master advanced content projection patterns in Angular
- [28. Dynamic Components](https://resources.devweekends.com/courses/angular-crash-course/28-dynamic-components.md): Create and manage dynamic components at runtime in Angular
- [29. Custom Schematics](https://resources.devweekends.com/courses/angular-crash-course/29-custom-schematics.md): Create custom Angular CLI schematics and builders
- [30. Error Handling](https://resources.devweekends.com/courses/angular-crash-course/30-error-handling.md): Implement robust global error handling in Angular applications
- [31. Interview Questions](https://resources.devweekends.com/courses/angular-crash-course/31-interview-questions.md): Comprehensive Angular interview preparation guide
- [32. Best Practices](https://resources.devweekends.com/courses/angular-crash-course/32-best-practices.md): Angular coding standards, architecture patterns, and style guide
- [33. Enterprise Capstone Project](https://resources.devweekends.com/courses/angular-crash-course/33-enterprise-capstone.md): Build a complete enterprise Angular application from scratch
- [Azure Cloud Engineering](https://resources.devweekends.com/courses/azure-cloud-engineering/00-overview.md): Master Microsoft Azure from fundamentals to advanced cloud architecture and engineering
- [Azure Fundamentals & Architecture](https://resources.devweekends.com/courses/azure-cloud-engineering/01-azure-fundamentals.md): Master Azure's global infrastructure, shared responsibility model, and core architectural principles
- [Identity & Access Management](https://resources.devweekends.com/courses/azure-cloud-engineering/02-identity-access-management.md): Master Azure Active Directory, RBAC, Conditional Access, and zero-trust security
- [03a. Networking Fundamentals](https://resources.devweekends.com/courses/azure-cloud-engineering/03a-networking-fundamentals.md): Master Subnets, CIDR, Network Security Groups, and Private Links
- [03b. Hybrid & Enterprise](https://resources.devweekends.com/courses/azure-cloud-engineering/03b-hybrid-networking.md): Master ExpressRoute, VPN, Virtual WAN, and Routing
- [03c. Traffic & Security](https://resources.devweekends.com/courses/azure-cloud-engineering/03c-traffic-management.md): Master Load Balancing, Front Door, Application Gateway, and Azure DNS
- [Compute Services](https://resources.devweekends.com/courses/azure-cloud-engineering/04-compute-services.md): Master Azure VMs, VM Scale Sets, App Service, and compute optimization strategies
- [Storage Solutions](https://resources.devweekends.com/courses/azure-cloud-engineering/05-storage-solutions.md): Master Azure Storage: Blob, Files, Disks, and data management strategies
- [Database Services](https://resources.devweekends.com/courses/azure-cloud-engineering/06-database-services.md): Master Azure SQL, Cosmos DB, PostgreSQL, and database optimization strategies
- [Azure Kubernetes Service (AKS)](https://resources.devweekends.com/courses/azure-cloud-engineering/07-container-kubernetes.md): Master container orchestration with AKS, networking, scaling, and production best practices
- [Serverless Architecture](https://resources.devweekends.com/courses/azure-cloud-engineering/08-serverless-architecture.md): Master Azure Functions, Logic Apps, and event-driven serverless patterns
- [Monitoring & Observability](https://resources.devweekends.com/courses/azure-cloud-engineering/09-monitoring-observability.md): Master Azure Monitor, Application Insights, Log Analytics, and KQL queries
- [Security & Compliance](https://resources.devweekends.com/courses/azure-cloud-engineering/10-security-compliance.md): Master Azure Security Center, Sentinel, and enterprise security patterns
- [DevOps & CI/CD](https://resources.devweekends.com/courses/azure-cloud-engineering/11-devops-cicd.md): Master Azure DevOps, GitHub Actions, and Infrastructure as Code
- [Cost Optimization](https://resources.devweekends.com/courses/azure-cloud-engineering/12-cost-optimization.md): Master Azure cost management, FinOps, and savings strategies
- [High Availability & Disaster Recovery](https://resources.devweekends.com/courses/azure-cloud-engineering/13-high-availability-dr.md): Master HA/DR strategies, RPO/RTO, and multi-region architectures
- [Architecture Patterns](https://resources.devweekends.com/courses/azure-cloud-engineering/14-architecture-patterns.md): Master real-world Azure architecture patterns and design principles
- [Capstone Project](https://resources.devweekends.com/courses/azure-cloud-engineering/15-capstone-project.md): Build a complete enterprise-grade e-commerce platform on Azure
- [API Management & Messaging Patterns](https://resources.devweekends.com/courses/azure-cloud-engineering/16-api-messaging.md): Master Azure API Management, Service Bus, Event Hub, and event-driven architectures
- [SRE & Production Excellence](https://resources.devweekends.com/courses/azure-cloud-engineering/17-sre-production.md): Master Site Reliability Engineering, SLIs/SLOs/SLAs, error budgets, chaos engineering, and production operations
- [Chapter 1: Linux Namespaces](https://resources.devweekends.com/courses/build-your-own-x/docker-1-namespaces.md): Understand and implement Linux namespaces - the foundation of container isolation
- [Chapter 2: Control Groups (cgroups)](https://resources.devweekends.com/courses/build-your-own-x/docker-2-cgroups.md): Implement resource limits using Linux cgroups for CPU, memory, and process control
- [Chapter 3: Filesystem Isolation](https://resources.devweekends.com/courses/build-your-own-x/docker-3-filesystem.md): Implement overlay filesystems and copy-on-write for efficient container storage
- [Chapter 4: Container Networking](https://resources.devweekends.com/courses/build-your-own-x/docker-4-networking.md): Implement container networking with virtual ethernet, bridges, and port forwarding
- [Chapter 5: Container Images](https://resources.devweekends.com/courses/build-your-own-x/docker-5-images.md): Understand OCI image format, layers, manifests, and implement image pulling
- [Build Your Own Docker](https://resources.devweekends.com/courses/build-your-own-x/docker-overview.md): Master Linux internals by building a container runtime from scratch — namespaces, cgroups, and overlay filesystems
- [Chapter 1: Project Setup & Init](https://resources.devweekends.com/courses/build-your-own-x/git-1-setup.md): Set up your Git clone project and implement the init command to understand repository structure
- [Chapter 2: The Object Model](https://resources.devweekends.com/courses/build-your-own-x/git-2-objects.md): Implement Git's content-addressable storage with blobs, trees, and SHA-1 hashing
- [Chapter 3: Staging & Index](https://resources.devweekends.com/courses/build-your-own-x/git-3-staging.md): Implement Git's staging area (index) and the add and status commands
- [Chapter 4: Commits & History](https://resources.devweekends.com/courses/build-your-own-x/git-4-commits.md): Implement the commit command and learn how Git builds and traverses history
- [Chapter 5: Branches & Checkout](https://resources.devweekends.com/courses/build-your-own-x/git-5-branches.md): Implement branching, checkout, and understand how Git manages multiple lines of development
- [Build Your Own Git](https://resources.devweekends.com/courses/build-your-own-x/git-overview.md): Understand version control by building Git from scratch — SHA-1 hashing, trees, commits, and branching
- [Build Your Own X](https://resources.devweekends.com/courses/build-your-own-x/overview.md): Build impressive projects from scratch — a Redis clone, Git, and Docker. Stand out in interviews with deep systems knowledge.
- [Chapter 1: RESP Protocol](https://resources.devweekends.com/courses/build-your-own-x/redis-1-protocol.md): Understand and implement Redis Serialization Protocol - the foundation of Redis communication
- [Chapter 2: TCP Server](https://resources.devweekends.com/courses/build-your-own-x/redis-2-server.md): Build a concurrent TCP server that handles Redis client connections with goroutines
- [Chapter 3: Data Structures](https://resources.devweekends.com/courses/build-your-own-x/redis-3-data-structures.md): Implement Redis data structures - Lists, Sets, Hashes, and Sorted Sets with skip lists
- [Chapter 4: Persistence](https://resources.devweekends.com/courses/build-your-own-x/redis-4-persistence.md): Implement Redis persistence with RDB snapshots and AOF logging for durability
- [Chapter 5: Pub/Sub](https://resources.devweekends.com/courses/build-your-own-x/redis-5-pubsub.md): Implement Redis Pub/Sub for real-time messaging and event streaming
- [Build Your Own Redis](https://resources.devweekends.com/courses/build-your-own-x/redis-overview.md): Master networking, protocols, and data structures by building Redis from scratch in Go
- [Concurrency & Threading](https://resources.devweekends.com/courses/c-programming/concurrency.md): Master threads, synchronization, and concurrent programming in C
- [Data Structures in C](https://resources.devweekends.com/courses/c-programming/data-structures.md): Implement fundamental data structures in C from scratch
- [Debugging Fundamentals](https://resources.devweekends.com/courses/c-programming/debugging.md): Master GDB, core dumps, and systematic debugging for C programs
- [Dynamic Memory Management](https://resources.devweekends.com/courses/c-programming/dynamic-memory.md): Master malloc, custom allocators, and memory management patterns
- [Embedded Systems](https://resources.devweekends.com/courses/c-programming/embedded.md): C programming for microcontrollers and constrained environments
- [Linux Kernel Modules](https://resources.devweekends.com/courses/c-programming/kernel-modules.md): Write code that runs inside the Linux kernel
- [Memory Layout & Segments](https://resources.devweekends.com/courses/c-programming/memory-layout.md): Deep dive into process memory layout, stack, heap, and data segments
- [Network Programming](https://resources.devweekends.com/courses/c-programming/networking.md): Build TCP/UDP clients and servers with Berkeley sockets
- [Advanced C Programming for Systems Development](https://resources.devweekends.com/courses/c-programming/overview.md): Master C programming for kernel development, embedded systems, compilers, and high-performance applications
- [Performance Optimization](https://resources.devweekends.com/courses/c-programming/performance.md): Squeeze every cycle out of your C code
- [Pointers Deep Dive](https://resources.devweekends.com/courses/c-programming/pointers.md): Complete mastery of C pointers — the foundation of systems programming
- [Preprocessor Mastery](https://resources.devweekends.com/courses/c-programming/preprocessor.md): Master macros, conditional compilation, and C code generation
- [Project: Memory Allocator](https://resources.devweekends.com/courses/c-programming/project-allocator.md): Build your own malloc implementation from scratch
- [Project: Key-Value Store](https://resources.devweekends.com/courses/c-programming/project-database.md): Build a persistent key-value database with indexing
- [Project: HTTP Server](https://resources.devweekends.com/courses/c-programming/project-http-server.md): Build a concurrent HTTP/1.1 server with epoll
- [Project: Build a Shell](https://resources.devweekends.com/courses/c-programming/project-shell.md): Build a fully functional Unix shell from scratch
- [C Syntax Speed Run](https://resources.devweekends.com/courses/c-programming/syntax-speedrun.md): Fast-track through C syntax for experienced programmers
- [System Calls & POSIX](https://resources.devweekends.com/courses/c-programming/system-calls.md): Understanding the interface between user space and kernel
- [Build Systems & Toolchain](https://resources.devweekends.com/courses/c-programming/toolchain.md): Master GCC, Make, CMake, and professional C development workflows
- [Undefined Behavior](https://resources.devweekends.com/courses/c-programming/undefined-behavior.md): Understanding and avoiding C's most dangerous pitfalls
- [Competitive Programming Mastery](https://resources.devweekends.com/courses/competitive-programming/00-overview.md): The ultimate strategic guide to dominate Codeforces and ICPC with pattern recognition and winning strategies
- [Time Complexity Analysis](https://resources.devweekends.com/courses/competitive-programming/01-time-complexity.md): Learn to analyze your solutions and predict if they'll pass within time limits
- [8-Week Roadmap to Specialist](https://resources.devweekends.com/courses/competitive-programming/01a-8-week-roadmap.md): A structured 8-week plan to go from LeetCode solver to Codeforces Specialist (1400+)
- [Codeforces Survival Guide](https://resources.devweekends.com/courses/competitive-programming/01b-cf-guide.md): Everything LeetCode users need to know about Codeforces—ratings, contests, and how to not get destroyed
- [Upsolving & Editorials](https://resources.devweekends.com/courses/competitive-programming/01c-upsolving.md): How to learn from every problem—the skill that separates Specialists from Experts
- [Debugging & Stress Testing](https://resources.devweekends.com/courses/competitive-programming/01d-debugging.md): Find bugs faster—systematic debugging and stress testing for competitive programming
- [CF Problem Types](https://resources.devweekends.com/courses/competitive-programming/01e-problem-types.md): Recognize and solve the most common Codeforces problem types—what LeetCode doesn't teach you
- [The Art of Reading Problems](https://resources.devweekends.com/courses/competitive-programming/01f-reading-problems.md): Transform cryptic problem statements into crystal-clear solutions through systematic reading and visualization
- [The CP Mindset](https://resources.devweekends.com/courses/competitive-programming/01g-mindset.md): Master the mental game—dealing with failure, building confidence, and developing the psychology of a champion
- [Contest Day Mastery](https://resources.devweekends.com/courses/competitive-programming/01h-contest-day.md): Pre-contest rituals, live strategy, time management, and post-contest recovery
- [Mistake Journal System](https://resources.devweekends.com/courses/competitive-programming/01i-mistake-journal.md): Track, analyze, and eliminate your recurring mistakes with a systematic journal
- [Pattern Recognition](https://resources.devweekends.com/courses/competitive-programming/01j-pattern-recognition.md): Learn to instantly recognize common problem patterns and select the right algorithm
- [Fast I/O & Debugging](https://resources.devweekends.com/courses/competitive-programming/02-fast-io.md): Master input/output optimization and debugging techniques for competitive programming
- [CP Environment Setup](https://resources.devweekends.com/courses/competitive-programming/02a-environment-setup.md): Complete VS Code setup, templates, and workflow for competitive programming
- [CP Toolkit](https://resources.devweekends.com/courses/competitive-programming/02b-cp-toolkit.md): Battle-tested code snippets for every common CP scenario - copy, paste, and win
- [STL for Competitive Programming](https://resources.devweekends.com/courses/competitive-programming/03-stl.md): Master the C++ Standard Template Library—the competitive programmer's essential toolkit
- [Prefix Sum & Difference Arrays](https://resources.devweekends.com/courses/competitive-programming/04-prefix-sum.md): Master range queries and updates with these fundamental techniques
- [Two Pointers & Sliding Window](https://resources.devweekends.com/courses/competitive-programming/05-two-pointers.md): Transform O(n²) brute force into elegant O(n) solutions
- [Binary Search](https://resources.devweekends.com/courses/competitive-programming/06-binary-search.md): Master binary search on arrays and on the answer—the technique that separates good from great
- [Sorting & Custom Comparators](https://resources.devweekends.com/courses/competitive-programming/07-sorting.md): Strategic sorting techniques and custom comparators for competitive programming
- [Recursion & Backtracking](https://resources.devweekends.com/courses/competitive-programming/08-recursion.md): Master the art of breaking problems into subproblems and exploring all possibilities systematically
- [Greedy Algorithms](https://resources.devweekends.com/courses/competitive-programming/09-greedy.md): Master the art of making locally optimal choices that lead to globally optimal solutions
- [Divide & Conquer](https://resources.devweekends.com/courses/competitive-programming/10-divide-conquer.md): Master the paradigm of splitting problems in half, solving each part, and combining results
- [Dynamic Programming Fundamentals](https://resources.devweekends.com/courses/competitive-programming/11-dp-fundamentals.md): Master the most powerful technique in competitive programming—state design, transitions, and the DP mindset
- [DP on Grids & Advanced Patterns](https://resources.devweekends.com/courses/competitive-programming/12-dp-grids-intervals.md): Master 2D DP, interval DP, and bitmask DP for ICPC-level problems
- [Graph Fundamentals](https://resources.devweekends.com/courses/competitive-programming/13-graph-fundamentals.md): Master graph representations, traversals, and fundamental graph algorithms
- [Shortest Path Algorithms](https://resources.devweekends.com/courses/competitive-programming/14-shortest-paths.md): Master Dijkstra, Bellman-Ford, Floyd-Warshall, and 0-1 BFS for weighted graphs
- [Tree Algorithms](https://resources.devweekends.com/courses/competitive-programming/15-trees.md): Master tree traversals, LCA, tree DP, and hierarchical structures
- [Disjoint Set Union (Union-Find)](https://resources.devweekends.com/courses/competitive-programming/16-dsu.md): Master Union-Find for connectivity, components, and Kruskal's MST
- [Segment Trees](https://resources.devweekends.com/courses/competitive-programming/17-segment-trees.md): Master range queries, point updates, and lazy propagation
- [String Algorithms](https://resources.devweekends.com/courses/competitive-programming/18-strings.md): Master hashing, KMP, Z-function, and Trie for pattern matching
- [Bit Manipulation](https://resources.devweekends.com/courses/competitive-programming/19-bit-manipulation.md): Master bitwise operations, bitmasks, and XOR tricks for competitive programming
- [Contest Strategy](https://resources.devweekends.com/courses/competitive-programming/20-contest-strategy.md): Master the art of winning at Codeforces, ICPC, and competitive programming contests
- [CP Code Library](https://resources.devweekends.com/courses/competitive-programming/21-code-library.md): Ready-to-use implementations of essential algorithms and data structures
- [Quick Reference Card](https://resources.devweekends.com/courses/competitive-programming/22-quick-reference.md): Essential formulas, complexities, and patterns for quick lookup during contests
- [Number Theory for CP](https://resources.devweekends.com/courses/competitive-programming/23-number-theory.md): Master modular arithmetic, primes, combinatorics, and mathematical techniques for CP
- [Advanced Graph Algorithms](https://resources.devweekends.com/courses/competitive-programming/24-advanced-graphs.md): Master SCC, bridges, articulation points, 2-SAT, and advanced graph techniques
- [C++ Fundamentals](https://resources.devweekends.com/courses/cpp-crash-course/fundamentals.md): The building blocks: Compilation, Types, and Control Flow
- [Modern C++ Features](https://resources.devweekends.com/courses/cpp-crash-course/modern-cpp.md): C++11, C++14, C++17, and C++20
- [Object-Oriented Programming](https://resources.devweekends.com/courses/cpp-crash-course/oop.md): Classes, Inheritance, Polymorphism, and the Rule of Five
- [C++ Crash Course](https://resources.devweekends.com/courses/cpp-crash-course/overview.md): Master high-performance programming with modern C++
- [Pointers & Memory](https://resources.devweekends.com/courses/cpp-crash-course/pointers-memory.md): Mastering the stack, heap, pointers, and RAII
- [Standard Template Library](https://resources.devweekends.com/courses/cpp-crash-course/stl.md): Containers, Iterators, and Algorithms
- [PostgreSQL Architecture](https://resources.devweekends.com/courses/database-engineering/architecture.md): Complete system architecture and component interaction
- [System Design Case Studies](https://resources.devweekends.com/courses/database-engineering/case-studies.md): Real-world database design problems and solutions
- [Contributing to PostgreSQL](https://resources.devweekends.com/courses/database-engineering/contributing.md): Become a PostgreSQL open-source contributor
- [PostgreSQL Data Structures](https://resources.devweekends.com/courses/database-engineering/data-structures.md): Internal data structures that power PostgreSQL — B-Trees, heaps, pages, and beyond
- [Database Design & Modeling](https://resources.devweekends.com/courses/database-engineering/database-design.md): Design schemas that scale, maintain integrity, and evolve gracefully
- [Distributed Database Systems](https://resources.devweekends.com/courses/database-engineering/distributed-systems.md): Consensus, replication, sharding, and distributed transactions for engineers building database infrastructure
- [Query Execution Plans Mastery](https://resources.devweekends.com/courses/database-engineering/execution-plans-mastery.md): Master reading, understanding, and optimizing PostgreSQL execution plans with hands-on practice and cross-database comparisons
- [Indexing Deep Dive](https://resources.devweekends.com/courses/database-engineering/indexing.md): Master the art of database indexing for blazing-fast queries
- [PostgreSQL Internals](https://resources.devweekends.com/courses/database-engineering/internals.md): Understand how PostgreSQL works under the hood
- [Senior Interview Mastery](https://resources.devweekends.com/courses/database-engineering/interview-prep.md): Ace database questions in senior engineering interviews
- [Database Engineering Mastery](https://resources.devweekends.com/courses/database-engineering/overview.md): Senior-level PostgreSQL expertise — from internals to open-source contributions
- [Performance Engineering](https://resources.devweekends.com/courses/database-engineering/performance-engineering.md): Production performance analysis for database engineers at PlanetScale, Supabase, and beyond
- [Query Engine Deep Dive](https://resources.devweekends.com/courses/database-engineering/query-engine-deep-dive.md): Production-grade understanding of PostgreSQL's query engine for distributed database engineers
- [Query Optimization](https://resources.devweekends.com/courses/database-engineering/query-optimization.md): Systematic approaches to diagnose and fix slow queries
- [Query Processing Pipeline](https://resources.devweekends.com/courses/database-engineering/query-processing.md): How PostgreSQL transforms SQL text into execution results
- [Replication & High Availability](https://resources.devweekends.com/courses/database-engineering/replication.md): Build database systems that survive failures
- [Scaling Strategies](https://resources.devweekends.com/courses/database-engineering/scaling.md): Scale databases from thousands to millions of users
- [PostgreSQL Source Code](https://resources.devweekends.com/courses/database-engineering/source-code.md): Navigate and understand the PostgreSQL codebase for contributions
- [SQL Foundations](https://resources.devweekends.com/courses/database-engineering/sql-foundations.md): Master SQL from basics to advanced queries — the language of data
- [Storage Engine Deep Dive](https://resources.devweekends.com/courses/database-engineering/storage-deep-dive.md): MVCC, Vacuum, WAL, and Recovery internals for database engineers
- [Transactions & ACID](https://resources.devweekends.com/courses/database-engineering/transactions.md): Build reliable applications that handle failures gracefully
- [Deep Learning Mastery](https://resources.devweekends.com/courses/deep-learning-mastery/00-overview.md): From neurons to transformers - master deep learning from first principles to production systems
- [The Deep Learning Landscape](https://resources.devweekends.com/courses/deep-learning-mastery/01-landscape.md): What is deep learning, when should you use it, and how does it fit into the broader ML ecosystem
- [Perceptrons & Multi-Layer Networks](https://resources.devweekends.com/courses/deep-learning-mastery/02-perceptrons-mlp.md): Build neural networks from scratch - understand how neurons compute and learn
- [Backpropagation Deep Dive](https://resources.devweekends.com/courses/deep-learning-mastery/03-backpropagation.md): The algorithm that makes neural networks learn - chain rule, computational graphs, and gradient flow
- [Activation Functions](https://resources.devweekends.com/courses/deep-learning-mastery/04-activation-functions.md): ReLU, sigmoid, tanh, GELU, Swish - when to use which and why they matter
- [Loss Functions & Objectives](https://resources.devweekends.com/courses/deep-learning-mastery/05-loss-functions.md): MSE, cross-entropy, contrastive loss - defining what 'learning' means mathematically
- [Convolutional Neural Networks](https://resources.devweekends.com/courses/deep-learning-mastery/06-cnns.md): The architecture that revolutionized computer vision - convolutions, filters, and feature maps
- [Pooling, Stride & CNN Design](https://resources.devweekends.com/courses/deep-learning-mastery/07-cnn-design.md): Master modern CNN architectures - VGG, ResNet, EfficientNet - and learn the design principles behind effective convolutional networks
- [Recurrent Neural Networks](https://resources.devweekends.com/courses/deep-learning-mastery/08-rnns.md): Process sequential data with memory - understand how neural networks handle time-series, text, and temporal patterns
- [LSTMs & GRUs](https://resources.devweekends.com/courses/deep-learning-mastery/09-lstms-grus.md): Master gated recurrent architectures - how LSTM and GRU cells solve the vanishing gradient problem with memory gates
- [Attention Mechanism](https://resources.devweekends.com/courses/deep-learning-mastery/10-attention.md): Learn how attention enables neural networks to focus on relevant information - the foundation of modern NLP and transformers
- [Transformers](https://resources.devweekends.com/courses/deep-learning-mastery/11-transformers.md): Build the Transformer architecture from scratch - the model that revolutionized NLP and powers GPT, BERT, and modern AI
- [Generative Adversarial Networks](https://resources.devweekends.com/courses/deep-learning-mastery/12-gans.md): Master the art of generative AI with GANs - learn to create realistic images through adversarial training
- [Autoencoders & VAEs](https://resources.devweekends.com/courses/deep-learning-mastery/13-autoencoders.md): Master data compression and generative modeling with autoencoders and variational autoencoders
- [Diffusion Models](https://resources.devweekends.com/courses/deep-learning-mastery/14-diffusion.md): The technology behind DALL-E and Stable Diffusion - generate images from noise
- [Residual & Skip Connections](https://resources.devweekends.com/courses/deep-learning-mastery/15-residual-networks.md): How to train very deep networks - ResNets, DenseNets, and U-Nets
- [Normalization Techniques](https://resources.devweekends.com/courses/deep-learning-mastery/16-normalization.md): Batch norm, layer norm, and more - stabilizing training at scale
- [Regularization Techniques](https://resources.devweekends.com/courses/deep-learning-mastery/17-regularization.md): Dropout, weight decay, data augmentation, and beyond
- [Optimization Algorithms](https://resources.devweekends.com/courses/deep-learning-mastery/18-optimization.md): SGD, momentum, Adam, AdamW, and modern optimization strategies
- [Training Strategies at Scale](https://resources.devweekends.com/courses/deep-learning-mastery/19-training-strategies.md): Mixed precision, gradient accumulation, distributed training, and efficient training
- [Transfer Learning & Fine-tuning](https://resources.devweekends.com/courses/deep-learning-mastery/20-transfer-learning.md): Leverage pretrained models effectively for your tasks
- [Model Deployment](https://resources.devweekends.com/courses/deep-learning-mastery/21-deployment.md): Export, optimize, and deploy models to production
- [Debugging Deep Learning](https://resources.devweekends.com/courses/deep-learning-mastery/22-debugging.md): Diagnose training issues, gradient problems, and model failures
- [Vision Transformers](https://resources.devweekends.com/courses/deep-learning-mastery/23-vision-transformers.md): ViT, DeiT, Swin, and modern vision architectures
- [Multimodal Models](https://resources.devweekends.com/courses/deep-learning-mastery/24-multimodal.md): CLIP, vision-language models, and connecting modalities
- [Foundation Models & LLMs](https://resources.devweekends.com/courses/deep-learning-mastery/25-foundation-models.md): Scaling laws, emergent capabilities, and training large language models
- [Capstone Project](https://resources.devweekends.com/courses/deep-learning-mastery/26-capstone.md): Build a complete deep learning system from scratch
- [Mathematical Foundations for Deep Learning](https://resources.devweekends.com/courses/deep-learning-mastery/27-math-foundations.md): Master the linear algebra, calculus, and probability theory essential for understanding deep learning at a fundamental level
- [Weight Initialization Strategies](https://resources.devweekends.com/courses/deep-learning-mastery/28-weight-initialization.md): Master the art of weight initialization - the difference between a network that learns and one that fails
- [Gradient Flow Analysis](https://resources.devweekends.com/courses/deep-learning-mastery/29-gradient-flow.md): Deep dive into gradient dynamics - understanding, visualizing, and fixing gradient flow issues
- [Advanced CNN Architectures](https://resources.devweekends.com/courses/deep-learning-mastery/30-cnn-architectures.md): Master the evolution of CNN architectures - from VGGNet to EfficientNet and beyond
- [Sequence-to-Sequence Models](https://resources.devweekends.com/courses/deep-learning-mastery/31-seq2seq.md): Master encoder-decoder architectures, attention mechanisms, and beam search decoding
- [Self-Supervised Learning](https://resources.devweekends.com/courses/deep-learning-mastery/32-self-supervised.md): Master representation learning without labels - contrastive learning, BYOL, SimCLR, MAE, and more
- [Reinforcement Learning for Deep Learning](https://resources.devweekends.com/courses/deep-learning-mastery/33-rl-for-dl.md): Master RLHF, PPO, DPO, and reward-based optimization for training powerful AI systems
- [Neural Architecture Search](https://resources.devweekends.com/courses/deep-learning-mastery/34-nas.md): Automate the discovery of optimal neural network architectures with NAS techniques
- [Interpretability & Explainability](https://resources.devweekends.com/courses/deep-learning-mastery/35-interpretability.md): Understand what deep learning models learn - Grad-CAM, attention visualization, SHAP, and more
- [Adversarial Robustness](https://resources.devweekends.com/courses/deep-learning-mastery/36-adversarial-robustness.md): Understand adversarial attacks and build robust defenses - FGSM, PGD, certified robustness
- [Efficient Neural Network Architectures](https://resources.devweekends.com/courses/deep-learning-mastery/37-efficient-architectures.md): Design lightweight models for edge deployment - MobileNet, ShuffleNet, EfficientNet design principles
- [Graph Neural Networks](https://resources.devweekends.com/courses/deep-learning-mastery/38-graph-neural-networks.md): Learn on graph-structured data - GCN, GAT, GraphSAGE, message passing frameworks
- [3D Deep Learning](https://resources.devweekends.com/courses/deep-learning-mastery/39-3d-deep-learning.md): Process 3D data - point clouds, voxels, meshes with PointNet, 3D CNNs, and more
- [Object Detection Deep Dive](https://resources.devweekends.com/courses/deep-learning-mastery/40-object-detection.md): Master object detection - YOLO, Faster R-CNN, DETR, anchor-free methods
- [Semantic Segmentation](https://resources.devweekends.com/courses/deep-learning-mastery/41-semantic-segmentation.md): Per-pixel classification with U-Net, DeepLab, and panoptic segmentation
- [Hyperparameter Tuning](https://resources.devweekends.com/courses/deep-learning-mastery/42-hyperparameter-tuning.md): Systematic optimization with Optuna, Ray Tune, and Bayesian methods
- [Reproducibility](https://resources.devweekends.com/courses/deep-learning-mastery/43-reproducibility.md): Experiment tracking, versioning, and reproducible ML workflows
- [Memory-Efficient Training](https://resources.devweekends.com/courses/deep-learning-mastery/44-memory-efficient-training.md): Gradient checkpointing, mixed precision, and memory optimization
- [Quantization Deep Dive](https://resources.devweekends.com/courses/deep-learning-mastery/45-quantization-deep-dive.md): INT8, FP8, PTQ, QAT, and mixed-precision quantization
- [Knowledge Distillation](https://resources.devweekends.com/courses/deep-learning-mastery/46-knowledge-distillation.md): Transfer knowledge from large teacher to small student models
- [Continual Learning](https://resources.devweekends.com/courses/deep-learning-mastery/47-continual-learning.md): Learning new tasks without catastrophic forgetting
- [Docker Best Practices](https://resources.devweekends.com/courses/devops-tools/docker-best-practices.md): Security, optimization, and production readiness
- [Docker Compose](https://resources.devweekends.com/courses/devops-tools/docker-compose.md): Orchestrating multi-container applications
- [Docker Fundamentals](https://resources.devweekends.com/courses/devops-tools/docker-fundamentals.md): Core Docker concepts and commands
- [Building Docker Images](https://resources.devweekends.com/courses/devops-tools/docker-images.md): Mastering Dockerfiles, layers, and multi-stage builds
- [Docker Networking & Volumes](https://resources.devweekends.com/courses/devops-tools/docker-networking.md): Mastering container communication and data persistence
- [Docker Crash Course](https://resources.devweekends.com/courses/devops-tools/docker-overview.md): Master containerization with Docker - from fundamentals to production
- [Git Advanced Topics](https://resources.devweekends.com/courses/devops-tools/git-advanced.md): Master advanced Git techniques
- [Git Branching & Merging](https://resources.devweekends.com/courses/devops-tools/git-branching.md): Master Git's powerful branching model
- [Git Collaboration](https://resources.devweekends.com/courses/devops-tools/git-collaboration.md): Work with teams using remote repositories
- [Git Fundamentals](https://resources.devweekends.com/courses/devops-tools/git-fundamentals.md): Core Git concepts and basic commands
- [Git Hooks & Automation](https://resources.devweekends.com/courses/devops-tools/git-hooks.md): Automating tasks with Git Hooks and Husky
- [Git Crash Course](https://resources.devweekends.com/courses/devops-tools/git-overview.md): Master distributed version control - the skill every developer needs
- [Git Workflows](https://resources.devweekends.com/courses/devops-tools/git-workflows.md): Gitflow, Trunk-Based Development, and Feature Branches
- [Kafka Fundamentals](https://resources.devweekends.com/courses/devops-tools/kafka-fundamentals.md): Core Kafka concepts and architecture
- [Kafka Operations](https://resources.devweekends.com/courses/devops-tools/kafka-operations.md): Running, monitoring, and securing Kafka clusters in production
- [Kafka Crash Course](https://resources.devweekends.com/courses/devops-tools/kafka-overview.md): Master event streaming - the backbone of real-time data pipelines
- [Kafka Producers & Consumers](https://resources.devweekends.com/courses/devops-tools/kafka-producers-consumers.md): Publishing and consuming messages with Kafka APIs
- [Kafka Streams](https://resources.devweekends.com/courses/devops-tools/kafka-streams.md): Stream processing with Kafka Streams API and ksqlDB
- [Kubernetes Configuration](https://resources.devweekends.com/courses/devops-tools/kubernetes-config.md): Managing application configuration with ConfigMaps and Secrets
- [Kubernetes Fundamentals](https://resources.devweekends.com/courses/devops-tools/kubernetes-fundamentals.md): Core Kubernetes concepts and architecture
- [Kubernetes Crash Course](https://resources.devweekends.com/courses/devops-tools/kubernetes-overview.md): Master container orchestration - the platform that runs the modern internet
- [Kubernetes Services](https://resources.devweekends.com/courses/devops-tools/kubernetes-services.md): Exposing applications with Services and Ingress
- [Kubernetes Storage](https://resources.devweekends.com/courses/devops-tools/kubernetes-storage.md): Managing persistent storage with PVs, PVCs, and StorageClasses
- [Kubernetes on Windows & Linux](https://resources.devweekends.com/courses/devops-tools/kubernetes-windows-linux.md): Running hybrid clusters with Windows and Linux nodes
- [Kubernetes Workloads](https://resources.devweekends.com/courses/devops-tools/kubernetes-workloads.md): Deployments, StatefulSets, DaemonSets, and Jobs
- [Linux Fundamentals](https://resources.devweekends.com/courses/devops-tools/linux-fundamentals.md): Master the Linux command line and file system
- [System Monitoring](https://resources.devweekends.com/courses/devops-tools/linux-monitoring.md): Monitoring system performance and logs
- [Linux Networking](https://resources.devweekends.com/courses/devops-tools/linux-networking.md): Master Linux networking and SSH
- [Linux Crash Course](https://resources.devweekends.com/courses/devops-tools/linux-overview.md): Master the operating system that runs the world
- [Linux Permissions & Users](https://resources.devweekends.com/courses/devops-tools/linux-permissions.md): Master Linux file permissions and user management
- [Linux Process Management](https://resources.devweekends.com/courses/devops-tools/linux-processes.md): Manage Linux processes and services
- [Linux Shell Scripting](https://resources.devweekends.com/courses/devops-tools/linux-scripting.md): Automate tasks with Bash scripting
- [Security Hardening](https://resources.devweekends.com/courses/devops-tools/linux-security.md): Securing Linux servers
- [DevOps Tools Mastery](https://resources.devweekends.com/courses/devops-tools/overview.md): Master essential DevOps tools from Git to Kubernetes - with deep dives into internals
- [RabbitMQ Fundamentals](https://resources.devweekends.com/courses/devops-tools/rabbitmq-fundamentals.md): Core RabbitMQ concepts and AMQP protocol
- [RabbitMQ Crash Course](https://resources.devweekends.com/courses/devops-tools/rabbitmq-overview.md): Master message queuing - the glue that holds distributed systems together
- [Patterns](https://resources.devweekends.com/courses/devops-tools/rabbitmq-patterns.md): RabbitMQ patterns
- [Reliability](https://resources.devweekends.com/courses/devops-tools/rabbitmq-reliability.md): RabbitMQ reliability
- [Byzantine Fault Tolerance (BFT)](https://resources.devweekends.com/courses/distributed-systems/bft.md): Consensus in the presence of malicious nodes, traitors, and arbitrary failures
- [Distributed Caching](https://resources.devweekends.com/courses/distributed-systems/caching.md): Cache architectures, consistency strategies, and patterns for high-performance distributed systems
- [Real-World Case Studies](https://resources.devweekends.com/courses/distributed-systems/case-studies.md): Deep dives into Google, Amazon, Netflix, and Uber's distributed systems with actual failure stories
- [Time & Clock Synchronization](https://resources.devweekends.com/courses/distributed-systems/clocks.md): Deep dive into physical clocks, logical clocks, and how distributed systems handle time
- [Consensus Protocols](https://resources.devweekends.com/courses/distributed-systems/consensus.md): Deep dive into Paxos, Raft, ZAB and other consensus algorithms - the heart of distributed systems
- [Consistency Models](https://resources.devweekends.com/courses/distributed-systems/consistency-models.md): Linearizability, serializability, causal consistency, and the consistency spectrum
- [Distributed Coordination](https://resources.devweekends.com/courses/distributed-systems/coordination.md): Zookeeper, etcd, service discovery, distributed locks, and leader election patterns
- [Data Systems at Scale](https://resources.devweekends.com/courses/distributed-systems/data-systems.md): Partitioning, consistent hashing, distributed databases, and stream processing
- [Fault Tolerance Patterns](https://resources.devweekends.com/courses/distributed-systems/fault-tolerance.md): Building resilient distributed systems with circuit breakers, bulkheads, retries, and graceful degradation
- [Formal Verification in Distributed Systems](https://resources.devweekends.com/courses/distributed-systems/formal-verification.md): Proving correctness with TLA+, PlusCal, and Model Checking
- [Foundations of Distributed Systems](https://resources.devweekends.com/courses/distributed-systems/foundations.md): Build the mental models that all distributed systems are built upon
- [Gossip Protocols & Membership](https://resources.devweekends.com/courses/distributed-systems/gossip.md): How nodes discover each other, detect failures, and spread information like an epidemic
- [Interview Practice Problems](https://resources.devweekends.com/courses/distributed-systems/interview-problems.md): Staff+ level distributed systems interview problems with detailed solutions
- [Distributed Messaging & Event Systems](https://resources.devweekends.com/courses/distributed-systems/messaging.md): Kafka, message queues, event sourcing, pub/sub patterns, and exactly-once semantics
- [Distributed Networking Fundamentals](https://resources.devweekends.com/courses/distributed-systems/networking.md): Network models, RPC frameworks, message delivery semantics, and failure detection for distributed systems
- [Distributed Systems Mastery](https://resources.devweekends.com/courses/distributed-systems/overview.md): Crack FAANG-level interviews with deep distributed systems expertise — Consensus, Raft, Paxos, and production patterns
- [Data Partitioning & Sharding](https://resources.devweekends.com/courses/distributed-systems/partitioning.md): Partitioning strategies, consistent hashing, rebalancing, and handling hot spots at scale
- [Paxos Consensus Deep Dive](https://resources.devweekends.com/courses/distributed-systems/paxos-deep-dive.md): From the basic Paxos protocol to Multi-Paxos, with detailed message flows, invariants, and implementation strategies
- [Production Excellence](https://resources.devweekends.com/courses/distributed-systems/production.md): Observability, chaos engineering, SRE practices, and operating distributed systems at scale
- [Raft Consensus Deep Dive](https://resources.devweekends.com/courses/distributed-systems/raft-deep-dive.md): Implementation-oriented, interview-level deep dive into the Raft consensus algorithm with invariants, failure scenarios, and step-by-step reasoning
- [Replication Strategies](https://resources.devweekends.com/courses/distributed-systems/replication.md): Single-leader, multi-leader, and leaderless replication patterns
- [Distributed Snapshots](https://resources.devweekends.com/courses/distributed-systems/snapshots.md): Understanding global state, the Chandy-Lamport algorithm, and snapshot isolation
- [Distributed Transactions](https://resources.devweekends.com/courses/distributed-systems/transactions.md): 2PC, 3PC, Saga pattern, and distributed locking mechanisms
- [Introduction and Motivation](https://resources.devweekends.com/courses/engineering-papers/chapter-1-introduction.md): Understanding the origins, design philosophy, and problem space that led to the creation of Google File System
- [Architecture Overview](https://resources.devweekends.com/courses/engineering-papers/chapter-2-architecture.md): Deep dive into GFS system architecture, components, and data flow patterns
- [Master Operations](https://resources.devweekends.com/courses/engineering-papers/chapter-3-master-operations.md): Deep dive into master operations: namespace management, metadata storage, chunk leases, replica placement, and garbage collection
- [Chunkservers and Data Flow](https://resources.devweekends.com/courses/engineering-papers/chapter-4-chunkservers-dataflow.md): Detailed exploration of chunk storage, replication pipeline, read/write/append operations, and data integrity mechanisms
- [Consistency Model](https://resources.devweekends.com/courses/engineering-papers/chapter-5-consistency-model.md): Understanding GFS's relaxed consistency guarantees, defined vs undefined regions, and application implications
- [Fault Tolerance](https://resources.devweekends.com/courses/engineering-papers/chapter-6-fault-tolerance.md): Comprehensive exploration of GFS fault tolerance mechanisms, failure handling, master and chunk replication, and recovery strategies
- [Performance and Optimizations](https://resources.devweekends.com/courses/engineering-papers/chapter-7-performance.md): Real-world GFS performance benchmarks, optimization techniques, bottleneck analysis, and production deployment insights
- [Impact and Evolution](https://resources.devweekends.com/courses/engineering-papers/chapter-8-impact-evolution.md): GFS's evolution to Colossus, influence on Hadoop HDFS and distributed systems, lessons learned, and lasting legacy
- [Introduction and Origins](https://resources.devweekends.com/courses/engineering-papers/dynamodb-chapter-1-introduction.md): Understanding the origins, design philosophy, and foundational Dynamo paper that led to Amazon DynamoDB
- [Architecture and Partitioning](https://resources.devweekends.com/courses/engineering-papers/dynamodb-chapter-2-architecture.md): Deep dive into DynamoDB's system architecture, consistent hashing, partitioning strategy, and request routing
- [Data Modeling in DynamoDB](https://resources.devweekends.com/courses/engineering-papers/dynamodb-chapter-3-data-model.md): Deep dive into DynamoDB data modeling patterns, single-table design, access patterns, and NoSQL design principles
- [Consistency Models in DynamoDB](https://resources.devweekends.com/courses/engineering-papers/dynamodb-chapter-4-consistency.md): Understanding eventual consistency, strong consistency, read-after-write consistency, and consistency trade-offs in distributed systems
- [Performance Optimization in DynamoDB](https://resources.devweekends.com/courses/engineering-papers/dynamodb-chapter-5-performance.md): Deep dive into DynamoDB performance optimization, throughput management, partition key design, caching strategies, and latency optimization
- [Advanced DynamoDB Features](https://resources.devweekends.com/courses/engineering-papers/dynamodb-chapter-6-advanced-features.md): Exploring DynamoDB Streams, Transactions, Global Tables, Time to Live, and other advanced features for building sophisticated applications
- [Fault Tolerance and Reliability](https://resources.devweekends.com/courses/engineering-papers/dynamodb-chapter-7-fault-tolerance.md): Understanding DynamoDB's built-in fault tolerance, backup and restore strategies, disaster recovery, and building resilient applications
- [DynamoDB in Production](https://resources.devweekends.com/courses/engineering-papers/dynamodb-chapter-8-production.md): Best practices, security, cost optimization, debugging, and real-world patterns for running DynamoDB in production environments
- [Amazon DynamoDB](https://resources.devweekends.com/courses/engineering-papers/dynamodb-overview.md): Master Amazon's fully managed NoSQL database that powers mission-critical applications at massive scale
- [Google File System](https://resources.devweekends.com/courses/engineering-papers/gfs-overview.md): Master the distributed file system that revolutionized large-scale storage and influenced Hadoop, HDFS, and modern cloud storage
- [Introduction and Origins](https://resources.devweekends.com/courses/engineering-papers/hadoop-chapter-1-introduction.md): Understanding Hadoop's origins, relationship to GFS and MapReduce, and the problems it was designed to solve
- [HDFS Architecture](https://resources.devweekends.com/courses/engineering-papers/hadoop-chapter-2-hdfs-architecture.md): Deep dive into Hadoop Distributed File System architecture, NameNode, DataNodes, and block management
- [MapReduce Framework](https://resources.devweekends.com/courses/engineering-papers/hadoop-chapter-3-mapreduce-framework.md): Deep dive into Hadoop MapReduce programming model, execution flow, and distributed data processing
- [YARN: Resource Management](https://resources.devweekends.com/courses/engineering-papers/hadoop-chapter-4-yarn.md): Deep dive into YARN architecture, resource management, and how Hadoop 2.x evolved beyond MapReduce
- [Hadoop Ecosystem](https://resources.devweekends.com/courses/engineering-papers/hadoop-chapter-5-ecosystem.md): Explore the rich ecosystem of tools built on Hadoop: Hive, Pig, HBase, Oozie, Kafka, and more
- [Fault Tolerance and Reliability](https://resources.devweekends.com/courses/engineering-papers/hadoop-chapter-6-fault-tolerance.md): Deep dive into Hadoop's fault tolerance mechanisms, recovery strategies, and building reliable distributed systems
- [Performance Tuning and Optimization](https://resources.devweekends.com/courses/engineering-papers/hadoop-chapter-7-performance.md): Master Hadoop performance tuning, optimization strategies, benchmarking, and best practices for production deployments
- [Hadoop in Production](https://resources.devweekends.com/courses/engineering-papers/hadoop-chapter-8-production.md): Enterprise-grade Hadoop operations: Kerberos security, Apache Ranger, monitoring, and disaster recovery.
- [Apache Hadoop](https://resources.devweekends.com/courses/engineering-papers/hadoop-overview.md): Master the distributed computing framework that revolutionized big data processing and enabled the modern data ecosystem
- [GCP Cloud Engineering](https://resources.devweekends.com/courses/gcp-cloud-engineering/00-overview.md): Master Google Cloud Platform from fundamentals to advanced cloud architecture and engineering with planet-scale depth
- [GCP Fundamentals](https://resources.devweekends.com/courses/gcp-cloud-engineering/01-gcp-fundamentals.md): Deep dive into Google's global infrastructure, the Jupiter network, and the hierarchical resource model
- [Identity & Security](https://resources.devweekends.com/courses/gcp-cloud-engineering/02-iam-security.md): Master GCP IAM, Service Accounts, Workload Identity, and the Principle of Least Privilege
- [Networking & VPC](https://resources.devweekends.com/courses/gcp-cloud-engineering/03-networking-vpc.md): Master GCP Virtual Private Cloud (VPC), global networking, Andromeda SDN, and Hybrid Connectivity
- [Load Balancing & DNS](https://resources.devweekends.com/courses/gcp-cloud-engineering/04-load-balancing-dns.md): Master Cloud Load Balancing, DNS, and CDN for global applications
- [Compute Engine](https://resources.devweekends.com/courses/gcp-cloud-engineering/05-compute-engine.md): Master Google Compute Engine (GCE), Virtual Machines, and Auto-scaling
- [Cloud Storage](https://resources.devweekends.com/courses/gcp-cloud-engineering/06-cloud-storage.md): Master Google Cloud Storage (GCS) and Object Storage concepts
- [Relational Databases](https://resources.devweekends.com/courses/gcp-cloud-engineering/07-relational-databases.md): Master Cloud SQL and Cloud Spanner for relational data workloads
- [NoSQL Databases](https://resources.devweekends.com/courses/gcp-cloud-engineering/08-nosql-databases.md): Master Firestore, Bigtable, and Memorystore for non-relational workloads
- [Containers & Artifacts](https://resources.devweekends.com/courses/gcp-cloud-engineering/09-containers-registry.md): Master Artifact Registry, Cloud Build, and Containerization on GCP
- [Google Kubernetes Engine](https://resources.devweekends.com/courses/gcp-cloud-engineering/10-google-kubernetes-engine.md): Master Google Kubernetes Engine (GKE) and enterprise Kubernetes management
- [Serverless Compute](https://resources.devweekends.com/courses/gcp-cloud-engineering/11-serverless-compute.md): Master Cloud Run, Cloud Functions, and App Engine on GCP
- [Data Analytics & BigQuery](https://resources.devweekends.com/courses/gcp-cloud-engineering/12-data-analytics-bigquery.md): Master BigQuery, Pub/Sub, and the GCP Data Analytics ecosystem
- [Monitoring & Observability](https://resources.devweekends.com/courses/gcp-cloud-engineering/13-monitoring-observability.md): Master Cloud Monitoring, Logging, and Error Reporting on GCP
- [Security & Compliance](https://resources.devweekends.com/courses/gcp-cloud-engineering/14-security-compliance.md): Master Cloud Armor, IAP, Secret Manager, and security hardening on GCP
- [IaC & Deployment](https://resources.devweekends.com/courses/gcp-cloud-engineering/15-iac-deployment.md): Master Terraform on GCP and Infrastructure as Code best practices
- [Hybrid & Multi-Cloud](https://resources.devweekends.com/courses/gcp-cloud-engineering/16-hybrid-multi-cloud.md): Master Anthos, Cloud Interconnect, and Hybrid Cloud architectures
- [Cost Management](https://resources.devweekends.com/courses/gcp-cloud-engineering/17-cost-management.md): Master GCP Billing, Budgets, and FinOps best practices
- [Capstone Project](https://resources.devweekends.com/courses/gcp-cloud-engineering/18-capstone-project.md): Build a production-grade, globally distributed application on GCP
- [Introduction to Go](https://resources.devweekends.com/courses/go-lang-mastery/01-introduction.md): History, philosophy, installation, and your first Go program
- [Variables and Types](https://resources.devweekends.com/courses/go-lang-mastery/02-variables-and-types.md): Understanding Go's type system, variables, constants, and zero values
- [Control Structures](https://resources.devweekends.com/courses/go-lang-mastery/03-control-structures.md): Loops, conditionals, and switch statements in Go
- [Functions and Packages](https://resources.devweekends.com/courses/go-lang-mastery/04-functions-and-packages.md): Function syntax, multiple return values, and package organization
- [Arrays, Slices, and Maps](https://resources.devweekends.com/courses/go-lang-mastery/05-arrays-slices-maps.md): Working with composite types and understanding slice internals
- [Pointers and Structs](https://resources.devweekends.com/courses/go-lang-mastery/06-pointers-and-structs.md): Understanding pointers, struct definitions, and methods
- [Interfaces](https://resources.devweekends.com/courses/go-lang-mastery/07-interfaces.md): Polymorphism in Go, implicit implementation, and type assertions
- [08. Concurrency](https://resources.devweekends.com/courses/go-lang-mastery/08-concurrency.md): Mastering Go's concurrency model: Goroutines, Channels, Select, and Sync primitives.
- [09. Error Handling](https://resources.devweekends.com/courses/go-lang-mastery/09-error-handling.md): Understanding Go's explicit error handling philosophy, custom errors, and panic/recover.
- [10. Testing and Benchmarking](https://resources.devweekends.com/courses/go-lang-mastery/10-testing-and-benchmarking.md): Writing robust software with Go's built-in testing, benchmarking, and fuzzing tools.
- [Generics](https://resources.devweekends.com/courses/go-lang-mastery/11-generics.md): Master Go's type parameters for writing flexible, reusable, and type-safe code
- [Advanced Concurrency Patterns](https://resources.devweekends.com/courses/go-lang-mastery/12-advanced-concurrency.md): Production-grade concurrency patterns: worker pools, pipelines, fan-out/fan-in, and more
- [Context Package](https://resources.devweekends.com/courses/go-lang-mastery/13-context.md): Master the context package for cancellation, deadlines, and request-scoped values
- [HTTP & Web Development](https://resources.devweekends.com/courses/go-lang-mastery/14-http-web.md): Build production-ready APIs with net/http, routing, middleware, and popular frameworks
- [Database Operations](https://resources.devweekends.com/courses/go-lang-mastery/15-databases.md): Working with SQL databases, ORMs, and NoSQL solutions in Go
- [Microservices & gRPC](https://resources.devweekends.com/courses/go-lang-mastery/16-microservices-grpc.md): Build distributed systems with gRPC, Protocol Buffers, and microservices patterns
- [Performance Optimization](https://resources.devweekends.com/courses/go-lang-mastery/17-performance.md): Profiling, benchmarking, memory optimization, and performance best practices
- [Production Best Practices](https://resources.devweekends.com/courses/go-lang-mastery/18-production.md): Logging, configuration, deployment, observability, and production-ready patterns
- [Design Patterns in Go](https://resources.devweekends.com/courses/go-lang-mastery/19-design-patterns.md): Idiomatic Go implementations of creational, structural, and behavioral patterns
- [Interview Preparation](https://resources.devweekends.com/courses/go-lang-mastery/20-interview-prep.md): Common Go interview questions, coding challenges, and system design topics
- [Access Control Systems](https://resources.devweekends.com/courses/hipaa-compliance/access-control.md): Implement enterprise-grade access control for healthcare applications with RBAC, ABAC, break-glass procedures, and HIPAA-compliant identity management
- [Audit Logging for HIPAA](https://resources.devweekends.com/courses/hipaa-compliance/audit-logging.md): Build tamper-proof audit trails for healthcare compliance
- [HIPAA Compliance Capstone Project](https://resources.devweekends.com/courses/hipaa-compliance/capstone-project.md): Build a complete HIPAA-compliant healthcare application from scratch, implementing everything learned throughout this course
- [HIPAA Breach Case Studies & Lessons Learned](https://resources.devweekends.com/courses/hipaa-compliance/case-studies.md): Analyze real-world HIPAA breaches, understand what went wrong, and learn prevention strategies from actual enforcement actions
- [Compliance Checklist & BAA](https://resources.devweekends.com/courses/hipaa-compliance/compliance-checklist.md): Complete HIPAA & PDPL compliance readiness checklist with Business Associate Agreements and risk assessment frameworks
- [HIPAA Database Security & Encryption](https://resources.devweekends.com/courses/hipaa-compliance/database-security.md): Master database-level security for healthcare applications including TDE, field-level encryption, secure queries, and backup strategies
- [E2E Encryption with AI Agents](https://resources.devweekends.com/courses/hipaa-compliance/e2e-encryption-ai.md): The holy grail: End-to-end encryption for chat while using LLMs for healthcare
- [Encryption: Data at Rest & In Transit](https://resources.devweekends.com/courses/hipaa-compliance/encryption.md): Implement comprehensive encryption for PHI protection
- [HIPAA Fundamentals](https://resources.devweekends.com/courses/hipaa-compliance/hipaa-fundamentals.md): Understanding Protected Health Information, covered entities, and HIPAA rules
- [Implementation Guide](https://resources.devweekends.com/courses/hipaa-compliance/implementation-guide.md): Complete reference implementation for HIPAA-compliant healthcare applications
- [Incident Response for Healthcare](https://resources.devweekends.com/courses/hipaa-compliance/incident-response.md): Build and execute HIPAA-compliant incident response programs with detection, containment, notification, and forensics procedures
- [HIPAA Compliance Mastery](https://resources.devweekends.com/courses/hipaa-compliance/overview.md): The definitive course for building production-ready healthcare applications with complete HIPAA compliance, advanced security architecture, and AI-safe data handling
- [PDPL & Global Data Protection](https://resources.devweekends.com/courses/hipaa-compliance/pdpl-compliance.md): Navigate Saudi Arabia's PDPL and international data protection regulations
- [HIPAA Risk Assessment](https://resources.devweekends.com/courses/hipaa-compliance/risk-assessment.md): Master the art of conducting comprehensive HIPAA risk assessments with practical frameworks, threat modeling, and documentation templates
- [HIPAA Vendor & Third-Party Risk Management](https://resources.devweekends.com/courses/hipaa-compliance/vendor-management.md): Master Business Associate Agreements, vendor due diligence, cloud compliance, and supply chain security for healthcare organizations
- [Collections Framework](https://resources.devweekends.com/courses/java-crash-course/collections.md): Lists, Sets, Maps, and Streams
- [Concurrency](https://resources.devweekends.com/courses/java-crash-course/concurrency.md): Threads, Executors, and Virtual Threads
- [Java Fundamentals](https://resources.devweekends.com/courses/java-crash-course/fundamentals.md): JVM Architecture, Types, and Control Flow
- [Modern Java Features](https://resources.devweekends.com/courses/java-crash-course/modern-java.md): Lambdas, Streams, Optional, and Pattern Matching
- [Object-Oriented Programming](https://resources.devweekends.com/courses/java-crash-course/oop.md): Classes, Interfaces, Records, and Sealed Classes
- [Java Crash Course](https://resources.devweekends.com/courses/java-crash-course/overview.md): Master the language of enterprise and scale
- [Async JavaScript](https://resources.devweekends.com/courses/javascript-crash-course/async.md): Callbacks, Promises, async/await, and the Event Loop
- [DOM & Browser APIs](https://resources.devweekends.com/courses/javascript-crash-course/dom-browser.md): Manipulating the DOM, Handling Events, and Browser APIs
- [Functions & Scope](https://resources.devweekends.com/courses/javascript-crash-course/functions-scope.md): First-class Functions, Closures, and the Execution Context
- [JavaScript Fundamentals](https://resources.devweekends.com/courses/javascript-crash-course/fundamentals.md): Variables, Types, Operators, and Control Flow
- [Modern JavaScript (ES6+)](https://resources.devweekends.com/courses/javascript-crash-course/modern-js.md): Destructuring, Modules, and the Latest Features
- [Objects & Prototypes](https://resources.devweekends.com/courses/javascript-crash-course/objects-prototypes.md): Objects, Prototypal Inheritance, and the `this` Keyword
- [JavaScript Crash Course](https://resources.devweekends.com/courses/javascript-crash-course/overview.md): Master the language of the web and beyond
- [Control Groups (cgroups)](https://resources.devweekends.com/courses/linux-internals/cgroups.md): Master cgroups v1 and v2 for resource limiting, accounting, and container isolation
- [Kernel Data Structures](https://resources.devweekends.com/courses/linux-internals/data-structures.md): Essential data structures used throughout the Linux kernel: linked lists, trees, RCU, and memory allocators
- [eBPF Deep Dive](https://resources.devweekends.com/courses/linux-internals/ebpf.md): Master eBPF for observability: architecture, program types, maps, verifier, and production tooling
- [Filesystem & VFS](https://resources.devweekends.com/courses/linux-internals/filesystem-vfs.md): Understand the Virtual File System layer, file descriptors, and Linux filesystem internals
- [Interrupts & Exception Handling](https://resources.devweekends.com/courses/linux-internals/interrupts-exceptions.md): Master interrupt handling, IRQ architecture, softirqs, tasklets, and workqueues in the Linux kernel
- [Real Interview Questions](https://resources.devweekends.com/courses/linux-internals/interview-questions.md): Actual Linux internals questions from Datadog, Grafana, Cloudflare, and top infrastructure companies
- [I/O Subsystem](https://resources.devweekends.com/courses/linux-internals/io-subsystem.md): Master Linux I/O internals: block layer, schedulers, and io_uring for high-performance applications
- [Linux Kernel Architecture](https://resources.devweekends.com/courses/linux-internals/kernel-architecture.md): Deep dive into Linux kernel design, source organization, boot process, and module system
- [Memory Management Internals](https://resources.devweekends.com/courses/linux-internals/memory-management.md): Deep dive into Linux memory management: zones, buddy allocator, slab, NUMA, and memory cgroups
- [Namespaces Deep Dive](https://resources.devweekends.com/courses/linux-internals/namespaces.md): Complete guide to Linux namespaces: the foundation of container isolation
- [Network Stack](https://resources.devweekends.com/courses/linux-internals/networking-stack.md): Deep dive into Linux networking internals: socket layer, TCP/IP stack, and performance tuning
- [Linux Internals & Kernel Mastery](https://resources.devweekends.com/courses/linux-internals/overview.md): Master Linux kernel internals for infrastructure, observability, and SRE roles at top tech companies
- [Power & Thermal Management](https://resources.devweekends.com/courses/linux-internals/power-management.md): Master Linux power management: cpufreq, cpuidle, thermal zones, and power optimization for cloud infrastructure
- [Process Subsystem Deep Dive](https://resources.devweekends.com/courses/linux-internals/process-subsystem.md): Complete guide to Linux process management, task_struct, scheduling, and CPU management
- [Hands-on Projects](https://resources.devweekends.com/courses/linux-internals/projects.md): Build real observability tools to cement your Linux internals knowledge
- [Security Modules & Capabilities](https://resources.devweekends.com/courses/linux-internals/security-modules.md): Deep dive into Linux security: LSM framework, SELinux, AppArmor, capabilities, and seccomp-bpf
- [Signals & IPC](https://resources.devweekends.com/courses/linux-internals/signals-ipc.md): Master Linux signal handling, shared memory, message queues, pipes, and inter-process communication
- [Kernel Synchronization](https://resources.devweekends.com/courses/linux-internals/synchronization.md): Master kernel locking mechanisms: spinlocks, mutexes, RCU, memory barriers, and debugging with lockdep
- [System Call Interface](https://resources.devweekends.com/courses/linux-internals/syscalls.md): Deep dive into syscall mechanism, vDSO, seccomp, and the user-kernel boundary
- [Tracing & Profiling](https://resources.devweekends.com/courses/linux-internals/tracing-profiling.md): Master Linux observability with perf, ftrace, bpftrace, and flame graphs for production debugging
- [Calculus for Machine Learning](https://resources.devweekends.com/courses/math-for-ml-calculus/00-introduction.md): Master derivatives, gradients, and optimization - the mathematics of learning
- [Derivatives & Rates of Change](https://resources.devweekends.com/courses/math-for-ml-calculus/01-derivatives.md): Understanding how things change - the foundation of machine learning
- [Gradients & Multivariable Calculus](https://resources.devweekends.com/courses/math-for-ml-calculus/02-gradients.md): Optimizing functions with many variables - the key to deep learning
- [Chain Rule & Backpropagation](https://resources.devweekends.com/courses/math-for-ml-calculus/03-chain-rule.md): How neural networks learn - understanding the chain rule through composition
- [Gradient Descent](https://resources.devweekends.com/courses/math-for-ml-calculus/04-gradient-descent.md): The algorithm that makes machines learn - understanding optimization through iteration
- [Optimization Techniques](https://resources.devweekends.com/courses/math-for-ml-calculus/05-optimization.md): Going beyond Gradient Descent - Momentum, RMSprop, and Adam
- [Final Project: Build a Neural Network](https://resources.devweekends.com/courses/math-for-ml-calculus/06-final-project.md): Build a complete Neural Network from scratch using only NumPy
- [Automatic Differentiation](https://resources.devweekends.com/courses/math-for-ml-calculus/07-automatic-differentiation.md): How PyTorch and TensorFlow compute gradients - the magic behind deep learning
- [Convex Optimization](https://resources.devweekends.com/courses/math-for-ml-calculus/08-convexity.md): When optimization is easy - understanding the landscapes that guarantee global solutions
- [Real-World Applications](https://resources.devweekends.com/courses/math-for-ml-calculus/09-real-world-applications.md): Calculus in production ML systems - from recommendation engines to self-driving cars
- [Introduction to Linear Algebra for ML](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/01-introduction.md): Why linear algebra is the language of machine learning
- [Vectors: The Language of Similarity](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/02-vectors.md): From finding similar houses to understanding how recommendations work
- [Matrices & Linear Transformations](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/03-matrices.md): From Excel spreadsheets to Instagram filters - understanding transformations
- [Project: Image Similarity Search Engine](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/04-project-image-search.md): Build a real image search engine using vectors and similarity measures
- [Eigenvalues & Eigenvectors](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/05-eigenvalues.md): Discovering which features matter most - the hidden structure in your data
- [Principal Component Analysis (PCA)](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/06-pca.md): Reduce dimensions while keeping the important information - from 10 features to 3
- [Singular Value Decomposition (SVD)](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/07-svd.md): The most powerful matrix decomposition - from Netflix recommendations to image compression
- [Linear Systems & Applications](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/08-linear-systems.md): Solve systems of equations - from circuit analysis to network flow optimization
- [Project: Music Recommendation Engine](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/09-project-recommender.md): Build a Spotify-style recommendation engine using SVD and matrix factorization
- [Orthogonality & Projections](https://resources.devweekends.com/courses/math-for-ml-linear-algebra/10-orthogonality.md): Understanding perpendicularity in high dimensions - the foundation of least squares and signal processing
- [Microservices Mastery](https://resources.devweekends.com/courses/microservices-mastery/00-overview.md): Master microservices architecture with Node.js and Python — From fundamentals to production-ready systems for top tech company interviews
- [1. Microservices Foundations](https://resources.devweekends.com/courses/microservices-mastery/01-foundations.md): Understand when and why to use microservices, monolith vs microservices tradeoffs, and key architectural principles
- [2. Domain-Driven Design](https://resources.devweekends.com/courses/microservices-mastery/02-domain-driven-design.md): Apply DDD principles to identify bounded contexts and design effective service boundaries
- [3. Synchronous Communication](https://resources.devweekends.com/courses/microservices-mastery/03-sync-communication.md): Master REST APIs and gRPC for synchronous service-to-service communication
- [4. Asynchronous Communication](https://resources.devweekends.com/courses/microservices-mastery/04-async-communication.md): Master message queues, event-driven architecture, and async patterns for microservices
- [5. API Gateway Pattern](https://resources.devweekends.com/courses/microservices-mastery/05-api-gateway.md): Implement API gateways for routing, authentication, rate limiting, and request aggregation
- [6. Data Management Patterns](https://resources.devweekends.com/courses/microservices-mastery/06-data-management.md): Master database per service, saga pattern, event sourcing, and CQRS for distributed data
- [7. Resilience Patterns](https://resources.devweekends.com/courses/microservices-mastery/07-resilience-patterns.md): Build fault-tolerant microservices with circuit breakers, retries, bulkheads, and fallback strategies
- [8. Service Discovery](https://resources.devweekends.com/courses/microservices-mastery/08-service-discovery.md): Implement service discovery with Consul, DNS-based discovery, and Kubernetes native solutions
- [9. Observability](https://resources.devweekends.com/courses/microservices-mastery/09-observability.md): Implement distributed tracing, structured logging, and metrics with OpenTelemetry, Prometheus, and Grafana
- [10. Security](https://resources.devweekends.com/courses/microservices-mastery/10-security.md): Secure microservices with authentication, authorization, mTLS, and secrets management
- [11. Containerization with Docker](https://resources.devweekends.com/courses/microservices-mastery/11-containerization.md): Master Docker for microservices with multi-stage builds, optimization, and docker-compose orchestration
- [12. Kubernetes Deployment](https://resources.devweekends.com/courses/microservices-mastery/12-kubernetes.md): Deploy and manage microservices on Kubernetes with deployments, services, ConfigMaps, and Helm charts
- [13. Testing Strategies](https://resources.devweekends.com/courses/microservices-mastery/13-testing.md): Master testing microservices with unit, integration, contract, and end-to-end testing patterns
- [14. Interview Preparation](https://resources.devweekends.com/courses/microservices-mastery/14-interview-prep.md): Comprehensive microservices interview questions, system design exercises, and preparation strategies
- [15. Capstone Project](https://resources.devweekends.com/courses/microservices-mastery/15-capstone.md): Build a complete e-commerce microservices system from scratch with all patterns and best practices
- [16. Service Mesh](https://resources.devweekends.com/courses/microservices-mastery/16-service-mesh.md): Master service mesh architecture with Istio and Linkerd for advanced traffic management, security, and observability
- [17. Configuration Management](https://resources.devweekends.com/courses/microservices-mastery/17-configuration-management.md): Master centralized configuration, feature flags, secrets management, and environment-specific settings for microservices
- [18. CI/CD for Microservices](https://resources.devweekends.com/courses/microservices-mastery/18-cicd.md): Master continuous integration and deployment pipelines for microservices with GitOps, canary deployments, and automated testing
- [19. Database Patterns](https://resources.devweekends.com/courses/microservices-mastery/19-database-patterns.md): Master database-per-service pattern, data consistency strategies, and migration techniques for microservices
- [20. Caching Strategies](https://resources.devweekends.com/courses/microservices-mastery/20-caching-strategies.md): Master distributed caching patterns, cache invalidation, and Redis implementations for high-performance microservices
- [21. Chaos Engineering](https://resources.devweekends.com/courses/microservices-mastery/21-chaos-engineering.md): Master chaos engineering principles with Chaos Monkey, failure injection, and resilience testing for robust microservices
- [22. Case Studies](https://resources.devweekends.com/courses/microservices-mastery/22-case-studies.md): Learn from real-world microservices architectures at Netflix, Uber, Amazon, and Spotify - what worked, what didn't, and key lessons
- [23. Load Balancing Deep Dive](https://resources.devweekends.com/courses/microservices-mastery/23-load-balancing.md): Master client-side vs server-side load balancing, algorithms, health checks, and advanced patterns for microservices
- [24. Migration Patterns](https://resources.devweekends.com/courses/microservices-mastery/24-migration-patterns.md): Master the art of migrating from monolith to microservices using Strangler Fig, Branch by Abstraction, and other proven patterns
- [25. Event Sourcing Deep Dive](https://resources.devweekends.com/courses/microservices-mastery/25-event-sourcing-deep-dive.md): Master event sourcing architecture, event stores, projections, snapshots, and CQRS patterns for microservices
- [26. GraphQL Federation](https://resources.devweekends.com/courses/microservices-mastery/26-graphql-federation.md): Build unified GraphQL APIs across microservices using Apollo Federation, schema stitching, and gateway patterns
- [Machine Learning Mastery](https://resources.devweekends.com/courses/ml-mastery/00-introduction.md): Learn machine learning the right way - starting with problems you already understand
- [The Prediction Game](https://resources.devweekends.com/courses/ml-mastery/01-prediction-game.md): Your first machine learning model - no libraries, just logic
- [Learning From Mistakes](https://resources.devweekends.com/courses/ml-mastery/02-learning-from-mistakes.md): Gradient descent - how machines learn by following the slope downhill
- [Linear Regression](https://resources.devweekends.com/courses/ml-mastery/03-linear-regression.md): Your first complete ML algorithm - fitting lines through points
- [Classification](https://resources.devweekends.com/courses/ml-mastery/04-classification.md): Predict categories - spam or not spam, cat or dog, buy or don't buy
- [K-Nearest Neighbors](https://resources.devweekends.com/courses/ml-mastery/04a-knn.md): The simplest ML algorithm - predict based on similar examples
- [Decision Trees](https://resources.devweekends.com/courses/ml-mastery/05-decision-trees.md): Make decisions like a flowchart - if this, then that
- [Support Vector Machines](https://resources.devweekends.com/courses/ml-mastery/05a-svm.md): Find the best boundary between classes with maximum margin
- [Naive Bayes](https://resources.devweekends.com/courses/ml-mastery/05b-naive-bayes.md): Simple probabilistic classification that's surprisingly powerful
- [Ensemble Methods](https://resources.devweekends.com/courses/ml-mastery/06-ensemble-methods.md): Combine many models for better predictions - the wisdom of crowds
- [Model Evaluation](https://resources.devweekends.com/courses/ml-mastery/07-model-evaluation.md): Measure what matters - accuracy is not enough
- [Feature Engineering](https://resources.devweekends.com/courses/ml-mastery/08-feature-engineering.md): Transform raw data into features that models can learn from
- [Hyperparameter Tuning](https://resources.devweekends.com/courses/ml-mastery/09-hyperparameter-tuning.md): Find the best settings for your model automatically
- [End-to-End ML Project](https://resources.devweekends.com/courses/ml-mastery/10-end-to-end-project.md): Build a complete machine learning project from scratch
- [Clustering](https://resources.devweekends.com/courses/ml-mastery/11-clustering.md): Group similar things together - unsupervised learning fundamentals
- [Neural Networks](https://resources.devweekends.com/courses/ml-mastery/12-neural-networks.md): From biology to math - understand how artificial neurons learn
- [Regularization](https://resources.devweekends.com/courses/ml-mastery/13-regularization.md): Fight overfitting - keep your model honest
- [Model Deployment](https://resources.devweekends.com/courses/ml-mastery/14-model-deployment.md): Take your model from notebook to production
- [Time Series Forecasting](https://resources.devweekends.com/courses/ml-mastery/15-time-series.md): Predicting the future from sequential data
- [Bias-Variance Tradeoff](https://resources.devweekends.com/courses/ml-mastery/16-bias-variance.md): The fundamental tradeoff that governs all machine learning
- [Data Leakage](https://resources.devweekends.com/courses/ml-mastery/17-data-leakage.md): The silent killer of ML models in production
- [Dimensionality Reduction](https://resources.devweekends.com/courses/ml-mastery/18-dimensionality-reduction.md): Handling high-dimensional data and the curse of dimensionality
- [Capstone Project](https://resources.devweekends.com/courses/ml-mastery/19-capstone-project.md): Build a complete ML system from problem to production
- [Handling Imbalanced Data](https://resources.devweekends.com/courses/ml-mastery/20-imbalanced-data.md): When 99% of your data is one class - techniques that actually work
- [Model Explainability](https://resources.devweekends.com/courses/ml-mastery/21-explainability.md): Understand why your model makes its predictions
- [ML Pipelines](https://resources.devweekends.com/courses/ml-mastery/22-ml-pipelines.md): Build reproducible, production-ready ML workflows
- [Common ML Mistakes](https://resources.devweekends.com/courses/ml-mastery/23-common-mistakes.md): Avoid the pitfalls that trip up even experienced practitioners
- [Cross-Validation Strategies](https://resources.devweekends.com/courses/ml-mastery/24-cross-validation.md): Master different cross-validation techniques for reliable model evaluation
- [Anomaly Detection](https://resources.devweekends.com/courses/ml-mastery/25-anomaly-detection.md): Learn to identify outliers and unusual patterns in data
- [ML at Scale](https://resources.devweekends.com/courses/ml-mastery/26-ml-at-scale.md): Production-grade machine learning - handling millions of samples and real-time predictions
- [01. Introduction to NoSQL & MongoDB](https://resources.devweekends.com/courses/mongodb-crash-course/01-intro-nosql.md): Understand the difference between SQL and NoSQL, and why MongoDB is popular.
- [02. Installation & MongoDB Compass](https://resources.devweekends.com/courses/mongodb-crash-course/02-setup-compass.md): Install MongoDB locally or use Atlas, and explore MongoDB Compass.
- [03. Databases & Collections](https://resources.devweekends.com/courses/mongodb-crash-course/03-databases-collections.md): Learn the hierarchy of data in MongoDB: Databases, Collections, and Documents.
- [04. CRUD: Create](https://resources.devweekends.com/courses/mongodb-crash-course/04-crud-create.md): Learn how to insert documents into a collection.
- [05. CRUD: Read (Query Operators)](https://resources.devweekends.com/courses/mongodb-crash-course/05-crud-read.md): Master MongoDB query operators to filter and find documents.
- [06. CRUD: Update](https://resources.devweekends.com/courses/mongodb-crash-course/06-crud-update.md): Learn how to modify existing documents using update operators.
- [07. CRUD: Delete](https://resources.devweekends.com/courses/mongodb-crash-course/07-crud-delete.md): Learn how to remove documents from a collection.
- [08. Aggregation Framework](https://resources.devweekends.com/courses/mongodb-crash-course/08-aggregation.md): Perform complex data analysis using the Aggregation Pipeline.
- [09. Indexing & Performance](https://resources.devweekends.com/courses/mongodb-crash-course/09-indexing.md): Optimize query performance using indexes.
- [10. Mongoose (ODM) Basics](https://resources.devweekends.com/courses/mongodb-crash-course/10-mongoose.md): Introduction to using Mongoose with Node.js.
- [Advanced Patterns](https://resources.devweekends.com/courses/nestjs/advanced-patterns.md)
- [Authentication & Authorization](https://resources.devweekends.com/courses/nestjs/authentication-authorization.md)
- [Controllers & Routing](https://resources.devweekends.com/courses/nestjs/controllers-routes.md)
- [Database Integration](https://resources.devweekends.com/courses/nestjs/database-integration.md)
- [Dependency Injection](https://resources.devweekends.com/courses/nestjs/dependency-injection.md)
- [Deployment & Production](https://resources.devweekends.com/courses/nestjs/deployment-production.md)
- [NestJS Fundamentals](https://resources.devweekends.com/courses/nestjs/fundamentals.md)
- [Microservices](https://resources.devweekends.com/courses/nestjs/microservices.md)
- [NestJS Mastery](https://resources.devweekends.com/courses/nestjs/overview.md): Build production-ready, scalable Node.js applications with NestJS
- [Providers & Services](https://resources.devweekends.com/courses/nestjs/providers-services.md)
- [Testing](https://resources.devweekends.com/courses/nestjs/testing.md)
- [Networking Fundamentals](https://resources.devweekends.com/courses/networking-mastery/01-overview.md): The complete networking course - from IP addressing to container networking, with real-world scenarios
- [Network Models](https://resources.devweekends.com/courses/networking-mastery/02-models.md): Deep dive into the OSI and TCP/IP reference models.
- [Physical & Data Link Layers](https://resources.devweekends.com/courses/networking-mastery/03-physical-datalink.md): Understanding the bottom layers: Cables, Ethernet, and Switching.
- [Network Layer](https://resources.devweekends.com/courses/networking-mastery/04-network-layer.md): IP Addressing, Subnetting, and Routing.
- [Transport Layer](https://resources.devweekends.com/courses/networking-mastery/05-transport-layer.md): TCP vs UDP, Flow Control, and Congestion Control.
- [Application Layer](https://resources.devweekends.com/courses/networking-mastery/06-application-layer.md): Protocols that power the web: HTTP, DNS, DHCP.
- [Network Security](https://resources.devweekends.com/courses/networking-mastery/07-security.md): Firewalls, VPNs, and Encryption.
- [Advanced Networking Intro](https://resources.devweekends.com/courses/networking-mastery/08-advanced.md): Introduction to SDN, Cloud Networking, and IPv6 - gateway to deep dive modules
- [IP Addressing Deep Dive](https://resources.devweekends.com/courses/networking-mastery/09-ip-addressing-deep-dive.md): Master CIDR notation, subnetting calculations, and the complete picture of IPv4/IPv6 addressing
- [NAT & PAT Deep Dive](https://resources.devweekends.com/courses/networking-mastery/10-nat-deep-dive.md): Master Network Address Translation - how millions of private devices share public IPs to access the internet
- [Routing Deep Dive](https://resources.devweekends.com/courses/networking-mastery/11-routing-deep-dive.md): Master routing tables, static vs dynamic routing, BGP, OSPF, and how packets find their way across the internet
- [DNS Deep Dive](https://resources.devweekends.com/courses/networking-mastery/12-dns-deep-dive.md): Master DNS - zones, records, resolution, propagation, and how domain names become IP addresses
- [Load Balancing & Proxies](https://resources.devweekends.com/courses/networking-mastery/13-load-balancing.md): Master load balancers, reverse proxies, and how traffic is distributed across servers
- [Network Troubleshooting](https://resources.devweekends.com/courses/networking-mastery/14-troubleshooting.md): Master the essential tools and techniques for diagnosing and resolving network issues
- [VPNs & Tunneling](https://resources.devweekends.com/courses/networking-mastery/15-vpn-tunneling.md): Understand VPN technologies, tunneling protocols, and secure remote network access
- [Real-World Networking Scenarios](https://resources.devweekends.com/courses/networking-mastery/16-scenarios.md): Complete end-to-end networking scenarios explaining how requests flow from client to server and back
- [Firewalls & Security Groups](https://resources.devweekends.com/courses/networking-mastery/17-firewalls-security-groups.md): Master network firewalls, security groups, NACLs, and network access control
- [Container Networking](https://resources.devweekends.com/courses/networking-mastery/18-container-networking.md): Master Docker networking, Kubernetes services, CNI, and service mesh concepts
- [01. Introduction & Setup](https://resources.devweekends.com/courses/node-crash-course/01-intro-setup.md): Get started with Node.js, understand its architecture, and set up your development environment.
- [02. Modules System](https://resources.devweekends.com/courses/node-crash-course/02-modules.md): Understand the Node.js module system, CommonJS, and how to create reusable code.
- [03. File System](https://resources.devweekends.com/courses/node-crash-course/03-file-system.md): Learn how to read, write, and manage files using the Node.js fs module.
- [04. Events & EventEmitter](https://resources.devweekends.com/courses/node-crash-course/04-events.md): Master the Event-Driven Architecture of Node.js using the EventEmitter class.
- [05. HTTP Module & Web Server](https://resources.devweekends.com/courses/node-crash-course/05-http-server.md): Create a raw HTTP server in Node.js without frameworks.
- [06. Streams & Buffers](https://resources.devweekends.com/courses/node-crash-course/06-streams-buffers.md): Understand how to handle data efficiently with Streams and Buffers.
- [07. NPM (Node Package Manager)](https://resources.devweekends.com/courses/node-crash-course/07-npm.md): Learn how to manage dependencies and scripts with NPM.
- [07b. Building and Publishing an NPM Package](https://resources.devweekends.com/courses/node-crash-course/07b-building-npm-package.md): A comprehensive guide to creating, testing, versioning, and publishing your own NPM packages.
- [08. Express.js Basics](https://resources.devweekends.com/courses/node-crash-course/08-express-basics.md): Introduction to Express.js, the most popular web framework for Node.js.
- [09. Building a REST API](https://resources.devweekends.com/courses/node-crash-course/09-rest-api.md): Learn how to build a complete RESTful API with Express.js.
- [10. Deployment & Best Practices](https://resources.devweekends.com/courses/node-crash-course/10-deployment.md): Learn how to prepare your Node.js application for production and deploy it.
- [11. Authentication with JWT](https://resources.devweekends.com/courses/node-crash-course/11-auth-jwt.md): Implement secure authentication using JSON Web Tokens (JWT) and bcrypt.
- [12. MongoDB & Mongoose ORM](https://resources.devweekends.com/courses/node-crash-course/12-mongo-mongoose.md): Connect Node.js to MongoDB using Mongoose.
- [13. PostgreSQL & Prisma ORM](https://resources.devweekends.com/courses/node-crash-course/13-postgres-prisma.md): Connect Node.js to PostgreSQL using Prisma ORM.
- [14. Error Handling & Debugging](https://resources.devweekends.com/courses/node-crash-course/14-error-handling.md): Master error handling patterns, debugging techniques, and logging in Node.js applications.
- [15. Testing with Jest](https://resources.devweekends.com/courses/node-crash-course/15-testing.md): Learn how to write unit tests, integration tests, and API tests for Node.js applications.
- [16. Real-Time with WebSockets](https://resources.devweekends.com/courses/node-crash-course/16-websockets.md): Build real-time applications using Socket.io for bidirectional communication.
- [17. Security Best Practices](https://resources.devweekends.com/courses/node-crash-course/17-security.md): Protect your Node.js applications from common vulnerabilities and attacks.
- [18. Performance & Caching](https://resources.devweekends.com/courses/node-crash-course/18-performance.md): Optimize Node.js applications for maximum performance with caching, clustering, and profiling.
- [19. Microservices Architecture](https://resources.devweekends.com/courses/node-crash-course/19-microservices.md): Design and implement microservices with Node.js, including communication patterns and deployment strategies.
- [20. TypeScript with Node.js](https://resources.devweekends.com/courses/node-crash-course/20-typescript.md): Build type-safe Node.js applications with TypeScript for better developer experience and fewer runtime errors.
- [21. Worker Threads & Child Processes](https://resources.devweekends.com/courses/node-crash-course/21-worker-threads.md): Handle CPU-intensive tasks and parallel processing in Node.js without blocking the event loop.
- [22. Capstone Project: Full-Stack API](https://resources.devweekends.com/courses/node-crash-course/22-capstone.md): Build a complete, production-ready REST API applying everything you've learned throughout the course.
- [All Courses](https://resources.devweekends.com/courses/overview.md): Browse our comprehensive collection of courses, from AI Engineering to Low-Level Systems.
- [Advanced Python](https://resources.devweekends.com/courses/python-crash-course/advanced.md): Decorators, Generators, Context Managers, and AsyncIO
- [Data Structures](https://resources.devweekends.com/courses/python-crash-course/data-structures.md): Lists, Dictionaries, Sets, and Tuples
- [Python Fundamentals](https://resources.devweekends.com/courses/python-crash-course/fundamentals.md): Variables, Types, and Control Flow
- [Modules & Packages](https://resources.devweekends.com/courses/python-crash-course/modules-packages.md): Imports, Standard Library, and Virtual Environments
- [Object-Oriented Programming](https://resources.devweekends.com/courses/python-crash-course/oop.md): Classes, Magic Methods, and Dataclasses
- [Python Crash Course](https://resources.devweekends.com/courses/python-crash-course/overview.md): Master the language of AI, Data, and Web
- [01. Introduction to React & JSX](https://resources.devweekends.com/courses/react-crash-course/01-intro-jsx.md): Get started with React, understand the Virtual DOM, and learn JSX syntax.
- [02. Components & Props](https://resources.devweekends.com/courses/react-crash-course/02-components-props.md): Learn about Functional Components, Props, and Component Composition patterns.
- [03. State & useState Hook](https://resources.devweekends.com/courses/react-crash-course/03-state-hook.md): Master component state management with the useState hook.
- [04. Handling Events](https://resources.devweekends.com/courses/react-crash-course/04-events.md): Master user interactions including clicks, forms, keyboard, and touch events.
- [05. Lists & Keys](https://resources.devweekends.com/courses/react-crash-course/05-lists-keys.md): Master rendering lists, understanding keys, and implementing advanced list patterns.
- [06. Forms & Controlled Components](https://resources.devweekends.com/courses/react-crash-course/06-forms.md): Master form handling, validation, and advanced form patterns in React.
- [07. useEffect & Side Effects](https://resources.devweekends.com/courses/react-crash-course/07-useeffect.md): Master side effects, data fetching, subscriptions, and lifecycle management.
- [08. Context API](https://resources.devweekends.com/courses/react-crash-course/08-context-api.md): Master global state management, avoid prop drilling, and implement advanced Context patterns.
- [09. React Router](https://resources.devweekends.com/courses/react-crash-course/09-react-router.md): Master client-side routing with React Router v6+ for building multi-page applications.
- [10. Performance Optimization](https://resources.devweekends.com/courses/react-crash-course/10-optimization.md): Master React performance optimization, profiling, and production-ready techniques.
- [11. Authentication & Protected Routes](https://resources.devweekends.com/courses/react-crash-course/11-authentication.md): Integrate JWT authentication in React and create protected routes.
- [12. Redux & State Management](https://resources.devweekends.com/courses/react-crash-course/12-redux-state.md): Master global state management with Redux Toolkit.
- [01. Introduction & Architecture](https://resources.devweekends.com/courses/react-native-crash-course/01-intro-architecture.md): Understanding React Native's architecture, the bridge, new architecture, and when to choose React Native
- [02. Environment Setup](https://resources.devweekends.com/courses/react-native-crash-course/02-environment-setup.md): Complete development environment setup for React Native on macOS, Windows, and Linux
- [03. Project Structure & Best Practices](https://resources.devweekends.com/courses/react-native-crash-course/03-project-structure.md): Organizing your React Native codebase for scalability, maintainability, and team collaboration
- [04. TypeScript in React Native](https://resources.devweekends.com/courses/react-native-crash-course/04-typescript.md): Type-safe React Native development with TypeScript patterns and best practices
- [05. Core Components Deep Dive](https://resources.devweekends.com/courses/react-native-crash-course/05-core-components.md): Master View, Text, Image, TextInput, Pressable, and all essential React Native components
- [6. Styling & Theming](https://resources.devweekends.com/courses/react-native-crash-course/06-styling-theming.md): Master styling techniques and build a robust theming system for React Native apps
- [7. Flexbox Mastery](https://resources.devweekends.com/courses/react-native-crash-course/07-flexbox-mastery.md): Complete guide to Flexbox layout in React Native
- [8. Navigation Fundamentals](https://resources.devweekends.com/courses/react-native-crash-course/08-navigation-fundamentals.md): Master React Navigation for building multi-screen React Native applications
- [9. Advanced Navigation](https://resources.devweekends.com/courses/react-native-crash-course/09-navigation-advanced.md): Complex navigation patterns and React Navigation advanced features
- [10. State Management](https://resources.devweekends.com/courses/react-native-crash-course/10-state-management.md): State management patterns in React Native
- [11. Redux & Zustand](https://resources.devweekends.com/courses/react-native-crash-course/11-redux-zustand.md): Global state management
- [15. React Query & Data Fetching](https://resources.devweekends.com/courses/react-native-crash-course/15-react-query.md): Master server state management with React Query for efficient data fetching
- [27. Unit Testing](https://resources.devweekends.com/courses/react-native-crash-course/27-unit-testing.md): Testing React Native components and logic with Jest and React Native Testing Library
- [31. Security Best Practices](https://resources.devweekends.com/courses/react-native-crash-course/31-security.md): Securing your React Native application with industry-standard security practices
- [35. Profiling & Monitoring](https://resources.devweekends.com/courses/react-native-crash-course/35-profiling.md): Performance profiling and production monitoring for React Native applications
- [40. CI/CD Pipelines](https://resources.devweekends.com/courses/react-native-crash-course/40-ci-cd.md): Automating builds, tests, and deployments for React Native applications
- [51. Capstone Project](https://resources.devweekends.com/courses/react-native-crash-course/51-capstone.md): Build a complete enterprise-grade React Native application from scratch
- [React Native Enterprise Mastery](https://resources.devweekends.com/courses/react-native-crash-course/overview.md): The complete guide to building production-ready, enterprise-grade mobile applications with React Native
- [Spring Boot & Microservices](https://resources.devweekends.com/courses/spring-boot-microservices/00-overview.md): Build production-grade microservices with Java, Spring Boot, and Spring Cloud
- [Spring Boot Quickstart](https://resources.devweekends.com/courses/spring-boot-microservices/01-spring-boot-quickstart.md): Bootstrap your first application and understand the magic
- [Spring MVC & REST](https://resources.devweekends.com/courses/spring-boot-microservices/02-spring-mvc-rest.md): Building powerful RESTful APIs
- [Data Persistence](https://resources.devweekends.com/courses/spring-boot-microservices/03-data-persistence.md): Spring Data JPA, Hibernate, and Transactions
- [Deep Dive: Spring AOP](https://resources.devweekends.com/courses/spring-boot-microservices/04-spring-aop.md): Aspect Oriented Programming internals
- [Testing Mastery](https://resources.devweekends.com/courses/spring-boot-microservices/05-spring-testing.md): Unit, Integration, and Contract Testing in Spring Boot
- [Foundations](https://resources.devweekends.com/courses/spring-boot-microservices/06-microservices-foundations.md): Monolith vs Microservices and DDD
- [Service Discovery](https://resources.devweekends.com/courses/spring-boot-microservices/07-service-discovery.md): Netflix Eureka and Client-Side Load Balancing
- [API Gateway](https://resources.devweekends.com/courses/spring-boot-microservices/08-api-gateway.md): Spring Cloud Gateway patterns
- [Config Management](https://resources.devweekends.com/courses/spring-boot-microservices/09-config-management.md): Centralized Configuration with Spring Cloud Config
- [Resilience & Fault Tolerance](https://resources.devweekends.com/courses/spring-boot-microservices/10-resilience.md): Circuit Breakers with Resilience4j
- [Observability](https://resources.devweekends.com/courses/spring-boot-microservices/11-observability.md): Distributed Tracing and Monitoring
- [Event Driven Architecture](https://resources.devweekends.com/courses/spring-boot-microservices/12-event-driven.md): Async communication with Kafka & RabbitMQ
- [Containerization](https://resources.devweekends.com/courses/spring-boot-microservices/13-containerization.md): Dockerizing Spring Boot Applications
- [Capstone Project](https://resources.devweekends.com/courses/spring-boot-microservices/14-capstone.md): Build an E-Commerce Microservices System
- [Probability and Statistics for Machine Learning](https://resources.devweekends.com/courses/statistics-for-ml/01-introduction.md): Master probability and statistics through real-world examples - from house prices to Netflix recommendations
- [Describing Data: What's Normal?](https://resources.devweekends.com/courses/statistics-for-ml/02-describing-data.md): Learn to summarize any dataset with mean, median, variance, and more
- [Probability Foundations: How Likely Is This?](https://resources.devweekends.com/courses/statistics-for-ml/03-probability.md): Master probability through real examples - from medical tests to spam detection
- [Probability Distributions: Patterns in Randomness](https://resources.devweekends.com/courses/statistics-for-ml/04-distributions.md): Discover the bell curve and other patterns that govern everything from test scores to stock prices
- [Statistical Inference: Conclusions from Samples](https://resources.devweekends.com/courses/statistics-for-ml/05-inference.md): How to draw reliable conclusions about millions from just hundreds of observations
- [Hypothesis Testing: Real Effect or Random Noise?](https://resources.devweekends.com/courses/statistics-for-ml/06-hypothesis-testing.md): The scientific method for determining if differences are meaningful
- [Correlation and Regression: Relationships and Predictions](https://resources.devweekends.com/courses/statistics-for-ml/07-regression.md): Discover how variables relate and build your first predictive models
- [From Statistics to Machine Learning](https://resources.devweekends.com/courses/statistics-for-ml/08-statistics-to-ml.md): Connect statistical foundations to modern machine learning algorithms
- [Bayesian Statistics](https://resources.devweekends.com/courses/statistics-for-ml/09-bayesian-statistics.md): Update beliefs with evidence - from spam filters to medical diagnosis
- [Time Series Fundamentals](https://resources.devweekends.com/courses/statistics-for-ml/10-time-series-basics.md): Analyze and forecast sequential data - from stock prices to weather patterns
- [Capstone Project: Complete Statistical Analysis](https://resources.devweekends.com/courses/statistics-for-ml/11-capstone-project.md): Apply everything you've learned to a real-world data analysis project
- [Jest Mastery](https://resources.devweekends.com/courses/testing-tools/jest.md): Master Zero-Config testing, advanced mocking, and snapshot strategies.
- [Mocha Mastery](https://resources.devweekends.com/courses/testing-tools/mocha.md): Advanced JavaScript testing, custom runners, complex mocking with Sinon, and browser automation.
- [Playwright Mastery](https://resources.devweekends.com/courses/testing-tools/playwright.md): Master modern end-to-end testing, network interception, and scalable patterns with Playwright.
- [Sonarqube Mastery](https://resources.devweekends.com/courses/testing-tools/sonarqube.md): Master static code analysis, custom quality gates, and securing your CI/CD pipeline.
- [Advanced Types](https://resources.devweekends.com/courses/typescript-crash-course/advanced-types.md): Union, Intersection, Conditional, Mapped, and Utility Types
- [Classes & OOP](https://resources.devweekends.com/courses/typescript-crash-course/classes-oop.md): Classes, Access Modifiers, Abstract Classes, and Decorators
- [Functions & Types](https://resources.devweekends.com/courses/typescript-crash-course/functions-types.md): Function Types, Overloads, and Type Guards
- [TypeScript Fundamentals](https://resources.devweekends.com/courses/typescript-crash-course/fundamentals.md): Types, Type Inference, and Basic Annotations
- [Generics Deep Dive](https://resources.devweekends.com/courses/typescript-crash-course/generics.md): Generic Functions, Classes, Constraints, and Real-World Patterns
- [Modules & Configuration](https://resources.devweekends.com/courses/typescript-crash-course/modules-config.md): ES Modules, Namespaces, tsconfig.json, and Project Setup
- [Objects & Interfaces](https://resources.devweekends.com/courses/typescript-crash-course/objects-interfaces.md): Interfaces, Type Aliases, and Object Type Patterns
- [TypeScript Crash Course](https://resources.devweekends.com/courses/typescript-crash-course/overview.md): Master the typed superset of JavaScript that scales
- [Airflow Core Concepts](https://resources.devweekends.com/distributed-systems-tools/airflow-core-concepts.md): Master DAGs, Tasks, Operators, TaskFlow API, dependencies, task relationships, and dynamic DAG generation
- [Airflow Operators](https://resources.devweekends.com/distributed-systems-tools/airflow-operators.md): Master built-in operators (BashOperator, PythonOperator, EmailOperator), custom operators, operator parameters, and best practices
- [What is Apache Airflow?](https://resources.devweekends.com/distributed-systems-tools/airflow-overview.md): Understanding workflow orchestration, Airflow architecture, use cases, and when to use Airflow vs other tools
- [Airflow Scheduling](https://resources.devweekends.com/distributed-systems-tools/airflow-scheduling.md): Master cron expressions, execution_date vs logical_date, catchup, backfill, trigger rules, and SLAs
- [Capstone Project](https://resources.devweekends.com/distributed-systems-tools/beam-capstone.md): Build a portable ETL pipeline
- [Core Programming Model](https://resources.devweekends.com/distributed-systems-tools/beam-core.md): Master PCollections and ParDo
- [Demystifying the Dataflow Model: Write Once, Run Anywhere with Apache Beam](https://resources.devweekends.com/distributed-systems-tools/beam-introduction.md): Master the unified batch/streaming model from Google's Dataflow paper - portable pipelines across Spark, Flink, and Dataflow
- [Beam I/O Connectors](https://resources.devweekends.com/distributed-systems-tools/beam-io.md): Connect to various data sources
- [Apache Beam Mastery](https://resources.devweekends.com/distributed-systems-tools/beam-overview.md): Master unified batch and stream processing with Apache Beam - write once, run anywhere on Spark, Flink, or Dataflow
- [Multi-Runner Execution](https://resources.devweekends.com/distributed-systems-tools/beam-runners.md): Deploy on Spark, Flink, Dataflow
- [Beam SQL](https://resources.devweekends.com/distributed-systems-tools/beam-sql.md): Declarative data processing
- [State & Timers](https://resources.devweekends.com/distributed-systems-tools/beam-state.md): Stateful processing with Beam
- [Triggers & Watermarks](https://resources.devweekends.com/distributed-systems-tools/beam-triggers.md): Control result materialization
- [Windowing & Time](https://resources.devweekends.com/distributed-systems-tools/beam-windowing.md): Time-based processing strategies
- [Cassandra Architecture & Storage Internals](https://resources.devweekends.com/distributed-systems-tools/cassandra-architecture-internals.md): Deep dive into Cassandra's ring topology, consistent hashing, vnodes, and native storage engine
- [Capstone: Building a Real-Time Analytics Platform](https://resources.devweekends.com/distributed-systems-tools/cassandra-capstone.md): Design and implement a production-ready, scalable IoT analytics platform using everything you've learned
- [Cluster Operations & Multi-DC Replication](https://resources.devweekends.com/distributed-systems-tools/cassandra-cluster-operations.md): Master gossip protocol, failure detection, repair mechanisms, and multi-datacenter replication strategies
- [Query-Driven Data Modeling in Cassandra](https://resources.devweekends.com/distributed-systems-tools/cassandra-data-modeling.md): Master Cassandra's query-driven approach, partition keys, clustering columns, and denormalization strategies
- [Apache Cassandra Mastery](https://resources.devweekends.com/distributed-systems-tools/cassandra-overview.md): Master Apache Cassandra from foundational papers to production-grade distributed NoSQL systems
- [The Cassandra Paper & Core Architecture](https://resources.devweekends.com/distributed-systems-tools/cassandra-paper.md): Deep dive into the seminal Cassandra paper from Facebook, explained in an accessible way with real-world context
- [Performance Tuning & Production Operations](https://resources.devweekends.com/distributed-systems-tools/cassandra-performance-production.md): Master JVM tuning, monitoring, troubleshooting, and running Cassandra at scale in production
- [Cassandra Read & Write Path Internals](https://resources.devweekends.com/distributed-systems-tools/cassandra-read-write-internals.md): Deep dive into how Cassandra processes reads and writes at the lowest level - from client request to disk I/O
- [Capstone: Production-Grade Real-Time Fraud Detection System](https://resources.devweekends.com/distributed-systems-tools/flink-capstone.md): Build a complete end-to-end fraud detection system using Flink, Kafka, CEP, ML, state management, and production monitoring
- [Complex Event Processing: Pattern Detection at Scale with Flink CEP](https://resources.devweekends.com/distributed-systems-tools/flink-cep.md): Master pattern detection in event streams - from CEP fundamentals to fraud detection, anomaly detection, and production patterns
- [DataStream API](https://resources.devweekends.com/distributed-systems-tools/flink-datastream.md): Master the low-level streaming API
- [Event Time & Watermarks](https://resources.devweekends.com/distributed-systems-tools/flink-eventtime.md): Handle out-of-order events with watermarks
- [Demystifying the Dataflow Model: True Stream Processing with Flink](https://resources.devweekends.com/distributed-systems-tools/flink-introduction.md): Master streaming foundations from the Dataflow Model paper - event time, watermarks, and why Flink is different
- [Production Flink: Deployment, Operations & Monitoring at Scale](https://resources.devweekends.com/distributed-systems-tools/flink-operations.md): Master production Flink deployments - Kubernetes, YARN, HA, state backends, checkpointing, monitoring, backpressure, and troubleshooting
- [Apache Flink Mastery](https://resources.devweekends.com/distributed-systems-tools/flink-overview.md): Master true stream processing with Apache Flink - from stateful computations to exactly-once guarantees
- [Declarative Stream Processing: Flink SQL & Table API Deep Dive](https://resources.devweekends.com/distributed-systems-tools/flink-sql.md): Master SQL-based stream processing - from dynamic tables to temporal joins, window aggregations, and production patterns
- [Demystifying Stateful Stream Processing: Flink's State Management Deep Dive](https://resources.devweekends.com/distributed-systems-tools/flink-state.md): Master Flink's managed state - from research foundations to production patterns with RocksDB and checkpointing
- [Windows & Time Operations](https://resources.devweekends.com/distributed-systems-tools/flink-windows.md): Time-based aggregations and windowing
- [Capstone Project: End-to-End Data Pipeline](https://resources.devweekends.com/distributed-systems-tools/hadoop-capstone.md): Build a production-ready, real-time log analytics platform using the full Hadoop ecosystem
- [Hadoop Ecosystem & Integration](https://resources.devweekends.com/distributed-systems-tools/hadoop-ecosystem.md): Master Hive, Pig, HBase, Sqoop, Flume, and other ecosystem tools for comprehensive big data solutions
- [HDFS Architecture & Internals](https://resources.devweekends.com/distributed-systems-tools/hadoop-hdfs.md): Master the Hadoop Distributed File System - architecture, replication, fault tolerance, and hands-on implementation
- [Advanced HDFS: Federation, HA & Erasure Coding](https://resources.devweekends.com/distributed-systems-tools/hadoop-hdfs-advanced.md): Master HDFS Federation, High Availability, Erasure Coding, Snapshots, and advanced performance optimization
- [Introduction & Foundational Papers](https://resources.devweekends.com/distributed-systems-tools/hadoop-introduction.md): Understand the theoretical foundations of Hadoop through the seminal GFS and MapReduce papers explained in an accessible way
- [MapReduce Programming Model](https://resources.devweekends.com/distributed-systems-tools/hadoop-mapreduce.md): Master distributed data processing with MapReduce - from basic patterns to advanced optimization techniques
- [Apache Hadoop Mastery](https://resources.devweekends.com/distributed-systems-tools/hadoop-overview.md): Master distributed computing with Apache Hadoop - from HDFS and MapReduce fundamentals to production-scale data processing
- [Data Processing Patterns & Best Practices](https://resources.devweekends.com/distributed-systems-tools/hadoop-patterns.md): Master design patterns, optimization techniques, and anti-patterns for efficient Hadoop data processing
- [Production Deployment & Operations](https://resources.devweekends.com/distributed-systems-tools/hadoop-production.md): Deploy, secure, monitor, and maintain production-grade Hadoop clusters at scale
- [YARN Resource Management](https://resources.devweekends.com/distributed-systems-tools/hadoop-yarn.md): Master YARN's architecture, scheduling policies, and resource management for multi-tenant Hadoop clusters
- [Neo4j Architecture & Native Graph Storage](https://resources.devweekends.com/distributed-systems-tools/neo4j-architecture-storage.md): Master Neo4j's native graph storage engine, index structures, transaction management, and performance optimization
- [Capstone: Building a Knowledge Graph Platform](https://resources.devweekends.com/distributed-systems-tools/neo4j-capstone.md): Build a production-ready knowledge graph with entity extraction, semantic search, recommendations, and graph analytics
- [Cypher Query Language Mastery](https://resources.devweekends.com/distributed-systems-tools/neo4j-cypher-mastery.md): Master Cypher pattern matching, aggregations, functions, and advanced query optimization techniques
- [Graph Data Modeling Best Practices](https://resources.devweekends.com/distributed-systems-tools/neo4j-data-modeling.md): Design efficient graph schemas, handle many-to-many relationships, refactor from relational models, and optimize for query patterns
- [Graph Algorithms at Scale](https://resources.devweekends.com/distributed-systems-tools/neo4j-graph-algorithms.md): Implement PageRank, community detection, shortest paths, centrality measures, and graph analytics using Neo4j GDS
- [Neo4j Graph Database Mastery](https://resources.devweekends.com/distributed-systems-tools/neo4j-overview.md): Master Neo4j from graph theory foundations to production-grade graph database systems
- [The Graph Database Story: From Theory to Neo4j](https://resources.devweekends.com/distributed-systems-tools/neo4j-paper.md): Explore the mathematical foundations of graph theory, the evolution of graph databases, and Neo4j's property graph model
- [Production Deployment & Operations](https://resources.devweekends.com/distributed-systems-tools/neo4j-production-deployment.md): Deploy Neo4j clusters with high availability, configure causal clustering, monitor performance, backup strategies, and production best practices
- [Advanced Topics](https://resources.devweekends.com/distributed-systems-tools/spark-advanced.md): Delta Lake, GraphX, and ecosystem integration
- [Capstone Project](https://resources.devweekends.com/distributed-systems-tools/spark-capstone.md): Build a real-time recommendation engine
- [Demystifying the RDD Paper: Spark's Foundation](https://resources.devweekends.com/distributed-systems-tools/spark-introduction.md): Understanding Resilient Distributed Datasets - the research paper that revolutionized big data processing
- [MLlib for Machine Learning](https://resources.devweekends.com/distributed-systems-tools/spark-mllib.md): Distributed machine learning at scale
- [Cluster Deployment](https://resources.devweekends.com/distributed-systems-tools/spark-operations.md): Deploy and manage Spark in production
- [Apache Spark Mastery](https://resources.devweekends.com/distributed-systems-tools/spark-overview.md): Master unified analytics with Apache Spark - from RDD foundations to Structured Streaming and MLlib
- [Demystifying RDD Programming: From Theory to Production](https://resources.devweekends.com/distributed-systems-tools/spark-rdd.md): Master the foundational RDD API with transformations, actions, partitioning, and production patterns
- [Spark SQL & DataFrames](https://resources.devweekends.com/distributed-systems-tools/spark-sql.md): Master DataFrames, Dataset API, SQL optimization, Catalyst optimizer, and structured data processing
- [Structured Streaming](https://resources.devweekends.com/distributed-systems-tools/spark-streaming.md): Real-time data processing with Structured Streaming
- [Performance Tuning](https://resources.devweekends.com/distributed-systems-tools/spark-tuning.md): Optimize Spark applications for production
- [Backtracking Pattern](https://resources.devweekends.com/dsa-patterns/backtracking.md): Solve constraint satisfaction problems with systematic exploration
- [Breadth-First Search (BFS)](https://resources.devweekends.com/dsa-patterns/bfs.md): Master BFS for shortest paths and level-order exploration
- [Binary Search Pattern](https://resources.devweekends.com/dsa-patterns/binary-search.md): Master binary search for sorted arrays and optimization problems
- [Bit Manipulation](https://resources.devweekends.com/dsa-patterns/bit-manipulation.md): Solve problems efficiently using bitwise operations
- [Depth-First Search (DFS)](https://resources.devweekends.com/dsa-patterns/dfs.md): Master DFS for trees, graphs, and recursive exploration problems
- [Divide and Conquer](https://resources.devweekends.com/dsa-patterns/divide-conquer.md): Break problems into subproblems, solve recursively, and combine results
- [Dynamic Programming](https://resources.devweekends.com/dsa-patterns/dynamic-programming.md): Master DP through state definition, transitions, and optimization
- [Graph Algorithms](https://resources.devweekends.com/dsa-patterns/graph-algorithms.md): Essential graph algorithms for interviews and competitive programming
- [Greedy Pattern](https://resources.devweekends.com/dsa-patterns/greedy.md): Solve optimization problems with locally optimal choices
- [HashMap Pattern](https://resources.devweekends.com/dsa-patterns/hashmap.md): Optimize lookup and counting problems with hash-based data structures
- [Heap / Priority Queue](https://resources.devweekends.com/dsa-patterns/heap.md): Efficiently find min/max elements with heap data structure
- [Linked List Patterns](https://resources.devweekends.com/dsa-patterns/linked-list.md): Master pointer manipulation for linked list problems
- [Monotonic Stack Pattern](https://resources.devweekends.com/dsa-patterns/monotonic-stack.md): Find next/previous greater/smaller elements efficiently
- [DSA Patterns Overview](https://resources.devweekends.com/dsa-patterns/overview.md): Master Data Structures and Algorithms through patterns, not memorization
- [Prefix Sum Pattern](https://resources.devweekends.com/dsa-patterns/prefix-sum.md): Precompute cumulative sums for O(1) range queries
- [Queue Pattern](https://resources.devweekends.com/dsa-patterns/queue.md): Master FIFO operations for BFS, scheduling, and stream processing
- [Recursion Pattern](https://resources.devweekends.com/dsa-patterns/recursion.md): Solve problems by breaking them into smaller self-similar subproblems
- [Sliding Window Pattern](https://resources.devweekends.com/dsa-patterns/sliding-window.md): Optimize subarray and substring problems with the sliding window technique
- [Sorting Algorithms](https://resources.devweekends.com/dsa-patterns/sorting.md): Master essential sorting techniques and their applications
- [Stack Pattern](https://resources.devweekends.com/dsa-patterns/stack.md): Master LIFO operations for parsing, matching, and monotonic problems
- [Trie (Prefix Tree)](https://resources.devweekends.com/dsa-patterns/trie.md): Efficiently store and search strings by prefix
- [Two Pointers Pattern](https://resources.devweekends.com/dsa-patterns/two-pointers.md): Master the two pointers technique for array and string problems
- [Union Find (Disjoint Set)](https://resources.devweekends.com/dsa-patterns/union-find.md): Efficiently track connected components with union-find operations
- [Architecture Patterns](https://resources.devweekends.com/engineering/architecture-patterns.md): Microservices, Monolith, Event-Driven, and other architectural patterns
- [Computer Science Fundamentals](https://resources.devweekends.com/engineering/cs-fundamentals.md): Core CS concepts every software engineer must know
- [Software Design Principles](https://resources.devweekends.com/engineering/design-principles.md): SOLID, DRY, KISS, and Clean Code practices for better software
- [DevOps & Infrastructure](https://resources.devweekends.com/engineering/devops.md): CI/CD, Containers, Kubernetes, and Cloud fundamentals
- [Engineering Topics](https://resources.devweekends.com/engineering/overview.md): Master core engineering concepts from fundamentals to advanced system design
- [Performance & Optimization](https://resources.devweekends.com/engineering/performance.md): Caching, Profiling, Load Testing, and Scaling strategies
- [Security Fundamentals](https://resources.devweekends.com/engineering/security.md): Authentication, Authorization, Encryption, and OWASP Top 10
- [DevWeekends Resources](https://resources.devweekends.com/index.md): Curated interview prep, open source programs, and engineering guides
- [Case Study: ATM System](https://resources.devweekends.com/lld/case-atm.md): Complete low-level design for an automated teller machine with state management
- [Case Study: Chess Game](https://resources.devweekends.com/lld/case-chess.md): Complete low-level design for a two-player chess game with all rules
- [Case Study: Elevator System](https://resources.devweekends.com/lld/case-elevator.md): Complete low-level design for a multi-elevator system with smart scheduling
- [Case Study: Hotel Booking System](https://resources.devweekends.com/lld/case-hotel-booking.md): Complete low-level design for a hotel room booking and reservation system
- [Case Study: Library Management System](https://resources.devweekends.com/lld/case-library.md): Complete low-level design for a library management system
- [Design LRU Cache](https://resources.devweekends.com/lld/case-lru-cache.md): LLD case study for a Least Recently Used cache implementation
- [Design Movie Ticket Booking System](https://resources.devweekends.com/lld/case-movie-ticket.md): LLD case study for an online movie ticket booking platform
- [Case Study: Parking Lot System](https://resources.devweekends.com/lld/case-parking-lot.md): Complete low-level design for a multi-level parking lot system
- [Design Vending Machine](https://resources.devweekends.com/lld/case-vending-machine.md): LLD case study for a vending machine with State pattern
- [Design Patterns](https://resources.devweekends.com/lld/design-patterns.md): Creational, Structural, and Behavioral patterns with practical examples
- [LLD Interview Cheat Sheet](https://resources.devweekends.com/lld/interview-cheatsheet.md): Quick reference guide for Low Level Design interviews - everything you need in one place
- [OOP Concepts](https://resources.devweekends.com/lld/oop-concepts.md): Core object-oriented programming concepts for LLD interviews
- [Abstraction](https://resources.devweekends.com/lld/oop/abstraction.md): Hide the complex stuff, show only what matters - like a TV remote!
- [Encapsulation](https://resources.devweekends.com/lld/oop/encapsulation.md): Learn to protect your data like a treasure chest with a lock
- [Inheritance](https://resources.devweekends.com/lld/oop/inheritance.md): Pass down abilities from parent to child - like superpowers in a family!
- [What is OOP?](https://resources.devweekends.com/lld/oop/introduction.md): Learn Object-Oriented Programming from scratch with fun real-world examples
- [Polymorphism](https://resources.devweekends.com/lld/oop/polymorphism.md): One interface, many forms - like a shape-shifter in code!
- [Low Level Design (LLD)](https://resources.devweekends.com/lld/overview.md): Master object-oriented design and build real-world systems
- [SOLID Principles in Practice](https://resources.devweekends.com/lld/solid-practice.md): Applying SOLID principles to real-world LLD scenarios
- [Dependency Inversion Principle](https://resources.devweekends.com/lld/solid/dip.md): Depend on abstractions, not concrete things - like plugging into a wall socket!
- [SOLID Introduction](https://resources.devweekends.com/lld/solid/introduction.md): Five magic rules that make your code super clean and easy to change!
- [Interface Segregation Principle](https://resources.devweekends.com/lld/solid/isp.md): Many small interfaces beat one giant interface - don't force unnecessary stuff!
- [Liskov Substitution Principle](https://resources.devweekends.com/lld/solid/lsp.md): Children should behave like parents - no surprises!
- [Open/Closed Principle](https://resources.devweekends.com/lld/solid/ocp.md): Add new features without changing existing code - like plugins!
- [Single Responsibility Principle](https://resources.devweekends.com/lld/solid/srp.md): One class, one job - like workers in a factory!
- [UML Diagrams](https://resources.devweekends.com/lld/uml-diagrams.md): Essential UML diagrams for Low Level Design interviews
- [The Boot Process: From Reset Vector to PID 1](https://resources.devweekends.com/operating-systems/boot-process.md): A deep dive into UEFI/BIOS, x86 mode transitions (Real to Long Mode), GDT/IDT initialization, and the Kernel entry sequence
- [OS Case Studies](https://resources.devweekends.com/operating-systems/case-studies.md): Real-world OS design decisions and production incidents
- [Containers & Virtualization: From Namespaces to Hypervisors](https://resources.devweekends.com/operating-systems/containers-virtualization.md): A deep dive into Namespaces, Cgroups, VMM architecture, and Hardware-Assisted Virtualization
- [CPU Architectures & Microarchitecture](https://resources.devweekends.com/operating-systems/cpu-architectures.md): A deep dive into Pipelines, Branch Prediction, Memory Consistency, and Cache Coherency
- [Deadlocks](https://resources.devweekends.com/operating-systems/deadlocks.md): Deadlock conditions, prevention, avoidance, detection, and recovery
- [Observability & Performance Engineering](https://resources.devweekends.com/operating-systems/debugging-performance.md): Hardware PMUs, LBR, ftrace, and Advanced Profiling
- [Virtual File System (VFS) & Disk Internals](https://resources.devweekends.com/operating-systems/file-systems.md): Inode architecture, Dentry caching, Path Lookup, and Journaling
- [Interview Preparation](https://resources.devweekends.com/operating-systems/interview-prep.md): Common OS interview questions, patterns, and strategies
- [I/O Systems & Modern I/O](https://resources.devweekends.com/operating-systems/io-systems.md): From DMA to io_uring: How the kernel handles massive throughput
- [Inter-Process Communication: Kernel Internals & Architecture](https://resources.devweekends.com/operating-systems/ipc.md): Pipe ring-buffers, Shared Memory MMU mapping, Signal frames, and Unix Domain Socket kernel paths
- [Linux Internals](https://resources.devweekends.com/operating-systems/linux-internals.md): Kernel architecture, system calls, modules, and boot process
- [Memory Management](https://resources.devweekends.com/operating-systems/memory-management.md): Physical memory allocation, segmentation, fragmentation, and memory protection
- [Modern OS Features](https://resources.devweekends.com/operating-systems/modern-features.md): io_uring, eBPF, modern schedulers, and cutting-edge kernel technologies
- [Kernel Networking Stack: From NIC to Socket](https://resources.devweekends.com/operating-systems/networking.md): Deep dive into sk_buff lifecycle, NAPI polling, XDP, TCP fast path, and zero-copy networking
- [OS Fundamentals & System Call Internals](https://resources.devweekends.com/operating-systems/os-fundamentals.md): Kernel vs User space, System Call mechanics, and the vDSO
- [Operating Systems Mastery](https://resources.devweekends.com/operating-systems/overview.md): Master OS internals for senior engineering interviews — processes, memory, concurrency, containers, networking & Linux kernel
- [Process Management](https://resources.devweekends.com/operating-systems/processes.md): Deep dive into process lifecycle, PCB, fork/exec, and context switching
- [CPU Scheduling](https://resources.devweekends.com/operating-systems/scheduling.md): Scheduling algorithms, CFS, real-time scheduling, and multi-core considerations
- [OS Security: From Hardware to Userspace](https://resources.devweekends.com/operating-systems/security.md): Deep dive into access control, capabilities, SELinux, ASLR, DEP, stack canaries, and microarchitectural attacks
- [Advanced Synchronization & RCU](https://resources.devweekends.com/operating-systems/synchronization.md): Lock-free structures, RCU internals, and Kernel Lock Validation
- [Threads & Concurrency: The Senior Mastery Guide](https://resources.devweekends.com/operating-systems/threads.md): TCB internals, assembly-level context switching, threading models, and high-performance concurrency
- [Virtual Memory](https://resources.devweekends.com/operating-systems/virtual-memory.md): Address spaces, paging, TLB, page replacement algorithms, and memory-mapped files
- [Operating System Interfaces](https://resources.devweekends.com/operating-systems/xv6.md): Master OS internals through xv6 - system calls, processes, I/O, pipes, and file systems
- [Productivity Sheets](https://resources.devweekends.com/productivity-sheets/overview.md): Planning templates to win interviews and ship projects
- [AI Engineer Interview Questions](https://resources.devweekends.com/resources/ai-engineer-interview-qs.md): Complete preparation guide covering LLMs, RAG systems, AI system design, deployment, monitoring, and safety
- [Analytical Puzzles](https://resources.devweekends.com/resources/analytical-puzzles.md): Classic puzzles frequently seen in interviews
- [CP / DSA Resources](https://resources.devweekends.com/resources/cp-dsa.md): Curated channels, playlists, and sheets for competitive programming
- [Engineering Channels, Books & Articles](https://resources.devweekends.com/resources/engineering-channels.md): Our recommendations for deep technical learning
- [Favourite Countries to Move](https://resources.devweekends.com/resources/favourite-countries.md): Factors and links for relocation decisions
- [Frontend Interview Questions](https://resources.devweekends.com/resources/frontend-interview-qs.md): Complete interview guide for Frontend Developers covering HTML, CSS, JavaScript, React, and Next.js
- [Good Books](https://resources.devweekends.com/resources/good-books.md): Handpicked books for mindset and productivity
- [Good Software Solutions](https://resources.devweekends.com/resources/good-software-solutions.md): Seed list of reputable software solution firms
- [Helpful Tools](https://resources.devweekends.com/resources/helpful-tools.md): Utilities that speed up branding, design, and workflow
- [International Companies](https://resources.devweekends.com/resources/international-companies.md): Starter list and research strategy for applying abroad
- [Interview Experiences](https://resources.devweekends.com/resources/interview-experiences.md): Real processes, questions, and notes from candidates
- [Behavioral & Leadership](https://resources.devweekends.com/resources/interview-questions/behavioral.md): STAR Method, Conflict Resolution, and Project Deep Dives
- [CI/CD & DevOps](https://resources.devweekends.com/resources/interview-questions/ci-cd.md): Pipelines, Testing, Deployment Strategies, and Security
- [Databases](https://resources.devweekends.com/resources/interview-questions/databases.md): SQL, NoSQL, Internals, Indexing, and Transactions
- [Docker](https://resources.devweekends.com/resources/interview-questions/docker.md): Containerization, Images, Networking, and Security
- [Express.js](https://resources.devweekends.com/resources/interview-questions/express.md): Middleware, Routing, and RESTful API Architecture
- [GCP Cloud](https://resources.devweekends.com/resources/interview-questions/gcp.md): Compute, Storage, GKE, Networking, and IAM
- [Go (Golang)](https://resources.devweekends.com/resources/interview-questions/go.md): GMP Scheduler, Channels, Interfaces, and Concurrency Patterns
- [Interview Prep Hub](https://resources.devweekends.com/resources/interview-questions/index.md): Senior Software Engineer Interview Preparation Guide
- [JavaScript (Deep Dive)](https://resources.devweekends.com/resources/interview-questions/javascript.md): V8 Internals, Event Loop, Closures, and Async Patterns
- [JavaScript (Fundamentals)](https://resources.devweekends.com/resources/interview-questions/javascript-basics.md): Comprehensive guide to JavaScript interview questions from Easy to Hard
- [Kubernetes](https://resources.devweekends.com/resources/interview-questions/kubernetes.md): Orchestration, GKE, Networking, and Troubleshooting
- [LLM & AI Systems](https://resources.devweekends.com/resources/interview-questions/llm-ai.md): Transformers, RAG, Training, and Evaluation
- [Mercor Interview Preparation](https://resources.devweekends.com/resources/interview-questions/mercor.md): Comprehensive Guide for Software Engineer Positions at Mercor
- [Node.js](https://resources.devweekends.com/resources/interview-questions/node.md): Runtime, Events, Streams, and Backend Scaling
- [Node.js (Fundamentals)](https://resources.devweekends.com/resources/interview-questions/node-basics.md): Event Loop, Streams, CPU Intensive Tasks, and Core Concepts
- [Python (Core & Backend)](https://resources.devweekends.com/resources/interview-questions/python.md): Core Language, OOP, Asyncio, and Backend Architecture
- [Python (Fundamentals)](https://resources.devweekends.com/resources/interview-questions/python-basics.md): From Basics to Advanced Topics - Comprehensive 2025 Edition
- [React (Deep Dive)](https://resources.devweekends.com/resources/interview-questions/react.md): Fiber Architecture, Hooks Internals, Patterns, and Performance
- [REST & Microservices](https://resources.devweekends.com/resources/interview-questions/rest-microservices.md): API Design, gRPC, Patterns, and Service Mesh
- [System Design](https://resources.devweekends.com/resources/interview-questions/system-design.md): Scalability, Distributed Systems, and Design Cases
- [APIs and Databases](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/apis-databases.md): API design (REST, gRPC, GraphQL), idempotency, rate limiting, versioning, database internals, indexing, transactions, replication, and data system selection
- [Authentication & Security](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/auth-security.md): Deep dive into authentication patterns, access control models, and application security -- covering OAuth, OIDC, SAML, JWT, Zero Trust, OWASP Top 10, and modern threat vectors with senior-engineer trade-off analysis
- [Caching & Observability](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/caching-observability.md): Master caching patterns, invalidation strategies, and production observability — logs, metrics, traces, and alerting for reliable systems.
- [Capacity Planning, Git & Data Pipelines](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/capacity-git-pipelines.md): Back-of-Envelope Math, Git Workflows, Code Review, and Batch Processing
- [Career Growth & Professional Development](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/career-growth.md): Engineering Levels, Growth Frameworks, and Career Strategy
- [Real-World Case Studies](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/case-studies.md): Production War Stories and Engineering Decision Analysis
- [Quick Reference Cheatsheet](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/cheatsheet.md): Essential Tables, Decision Matrices, and One-Page Summaries for Every Topic
- [Cloud Architecture, Problem Framing & Trade-Offs](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/cloud-problemframing-tradeoffs.md): Cloud Design, Requirement Analysis, and Engineering Judgment
- [Communication & Soft Skills](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/communication-softskills.md): How Senior Engineers Communicate, Collaborate, and Influence
- [Compliance, Cost & Debugging](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/compliance-cost-debugging.md): Governance, Engineering Economics, and Incident Response
- [Data Engineering](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/data-engineering.md): Pipelines, Warehouses, Stream Processing, and Building Reliable Data Systems at Scale -- from Batch to Real-Time
- [Database Deep Dives](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/database-deep-dives.md): PostgreSQL Internals, MongoDB Patterns, DynamoDB Strategies, and Redis Architecture
- [Design Patterns and Architecture](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/design-patterns.md): Code-level design patterns, architectural patterns, CQRS, event sourcing, microservices, and a practical guide to choosing the right pattern for the right problem.
- [DSA & The Answer Framework](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/dsa-answer-framework.md): Data Structures, Algorithm Patterns, and the 8-Step Framework for Any Engineering Question
- [The Engineering Mindset](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/engineering-mindset.md): Mental Models, Problem-Solving Frameworks, and How Senior Engineers Think
- [Leadership, Execution & Infrastructure](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/leadership-execution-infra.md): Product Thinking, Technical Debt Management, and Platform Engineering
- [Messaging, Concurrency & State](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/messaging-concurrency-state.md): Async Systems, Threading Models, and Distributed State
- [ML & AI Systems Engineering](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/ml-ai-systems.md): Model Serving, MLOps, LLM Infrastructure, RAG Architecture, and Building Production ML Systems -- from Training Pipelines to Real-Time Inference
- [Mobile Engineering](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/mobile-engineering.md): iOS, Android, Cross-Platform Architecture, Offline-First Patterns, and Building High-Performance Mobile Applications
- [Modern Engineering Practices](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/modern-engineering.md): AI-Assisted Development, Platform Engineering, and Emerging Industry Patterns
- [Multi-Tenancy, DDD & Documentation](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/multitenancy-ddd-docs.md): Isolation Models, Domain-Driven Design, and Engineering Communication
- [Networking & Deployment](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/networking-deployment.md): Network Fundamentals, Service Discovery, and Release Engineering
- [Think Like an Engineer](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/overview.md): The Weekend Deep-Dive: A Comprehensive Senior Engineering Study Guide — Think, Speak, Act, and Perform Like a Senior Engineer
- [Performance & Scalability](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/performance-scalability.md): Deep-dive into latency, throughput, query optimization, connection pooling, async processing, scaling strategies, sharding, backpressure, and autoscaling -- with real numbers, trade-off analysis, and senior-level interview answers.
- [Reference & Reading List](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/reference.md): Cross-Cutting Concerns, Interviewer Insights, Common Misconceptions, Essential Books, Tool Index, and Open Source Projects to Study
- [Reliability, Resilience & Software Engineering Principles](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/reliability-principles.md): SRE fundamentals, resilience patterns, availability strategies, SOLID principles, and technical debt management for senior engineering interviews
- [Security Engineering](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/security-engineering.md): Threat Modeling, Application Security, Infrastructure Hardening, Incident Response, and Building Defense-in-Depth Systems
- [System Design Practice](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/system-design-practice.md): Guided System Design Problems with Step-by-Step Engineering Thinking
- [Testing, Logging & Versioning](https://resources.devweekends.com/resources/interview-questions/think-like-an-engineer/testing-logging-versioning.md): Quality Engineering, Audit Trails, and Change Management
- [Java Interview Questions](https://resources.devweekends.com/resources/java-interview-qs.md): Complete interview guide for Java developers covering Core Java, OOP, Collections, Multithreading, and Spring
- [Job Prep & Branding](https://resources.devweekends.com/resources/job-prep-branding.md): Resume, LinkedIn, outreach, and interview strategy
- [MERN Stack Interview Questions](https://resources.devweekends.com/resources/mern-interview-qs.md): Complete interview guide MERN Stack questions and answers covering MongoDB, Express.js, React, and Node.js
- [Open Source Programs](https://resources.devweekends.com/resources/open-source-programs.md): Complete guides to every major open-source internship, mentorship, and fellowship program
- [24 Pull Requests](https://resources.devweekends.com/resources/open-source-programs/24-pull-requests.md): Guide to 24 Pull Requests — give back to open source every day in December
- [FOSSASIA Codeheat](https://resources.devweekends.com/resources/open-source-programs/fossasia-codeheat.md): Guide to FOSSASIA Codeheat — a beginner-friendly open-source coding contest with prizes
- [Google Season of Docs](https://resources.devweekends.com/resources/open-source-programs/google-season-of-docs.md): Complete guide to Google Season of Docs — get paid to write technical documentation for open-source projects
- [Google Summer of Code (GSoC)](https://resources.devweekends.com/resources/open-source-programs/gsoc.md): The complete guide to getting selected for GSoC — from choosing a project to writing a winning proposal
- [LF Networking Mentorship (LFN)](https://resources.devweekends.com/resources/open-source-programs/lfn-mentorship.md): Guide to the Linux Foundation Networking Mentorship — contribute to open-source networking projects
- [LFX Mentorship (Linux Foundation)](https://resources.devweekends.com/resources/open-source-programs/lfx-mentorship.md): Complete guide to the Linux Foundation Mentorship program — multiple cohorts per year, cloud-native projects, and paid stipends
- [Linux Kernel Mentorship](https://resources.devweekends.com/resources/open-source-programs/linux-kernel-mentorship.md): Guide to the Linux Kernel Mentorship Program — contribute to the Linux kernel under expert guidance
- [MLH Fellowship](https://resources.devweekends.com/resources/open-source-programs/mlh-fellowship.md): Complete guide to the MLH Fellowship — open source, software engineering, and SRE tracks with paid stipends
- [Open Source Promotion Plan (OSPP)](https://resources.devweekends.com/resources/open-source-programs/ospp.md): Guide to OSPP — China's open-source summer program by the Chinese Academy of Sciences, open to students worldwide
- [Outreachy](https://resources.devweekends.com/resources/open-source-programs/outreachy.md): Complete guide to Outreachy — paid remote internships for underrepresented groups in tech
- [Summer of Bitcoin](https://resources.devweekends.com/resources/open-source-programs/summer-of-bitcoin.md): Complete guide to Summer of Bitcoin — contribute to Bitcoin open-source projects and get paid in BTC
- [Product‑Based Companies (Pakistan)](https://resources.devweekends.com/resources/product-based-companies-pk.md): Initial list and how to research product orgs in PK
- [Python Interview Questions](https://resources.devweekends.com/resources/python-interview-qs.md): Complete preparation guide covering Python basics, data structures, OOP, advanced concepts, web development, and data science
- [Remote & AI Companies](https://resources.devweekends.com/resources/remote-ai-companies.md): Where to look for remote‑friendly and AI‑focused roles
- [Advanced Concepts](https://resources.devweekends.com/system-design/advanced-concepts.md): Senior-level system design concepts for Staff+ interviews
- [API Design](https://resources.devweekends.com/system-design/api-design.md): REST, GraphQL, API versioning, rate limiting, and best practices
- [System Design Building Blocks](https://resources.devweekends.com/system-design/building-blocks.md): Essential components for designing scalable systems
- [Design Google Maps](https://resources.devweekends.com/system-design/case-google-maps.md): System design for a navigation and mapping service with real-time traffic
- [Design: Netflix/YouTube](https://resources.devweekends.com/system-design/case-netflix.md): System design for video streaming platforms at scale
- [Design a Notification System](https://resources.devweekends.com/system-design/case-notification-system.md): System design for a multi-channel notification delivery platform
- [Design a Payment System](https://resources.devweekends.com/system-design/case-payment-system.md): System design for a scalable, reliable payment processing platform
- [Design: Rate Limiter](https://resources.devweekends.com/system-design/case-rate-limiter.md): System design for distributed rate limiting
- [Design: Twitter/X Timeline](https://resources.devweekends.com/system-design/case-twitter.md): System design for a social media timeline feed like Twitter
- [Design: Uber/Lyft](https://resources.devweekends.com/system-design/case-uber.md): System design for ride-hailing platforms with real-time matching
- [Design: URL Shortener](https://resources.devweekends.com/system-design/case-url-shortener.md): System design for a URL shortening service like bit.ly or TinyURL
- [Design: WhatsApp/Messenger](https://resources.devweekends.com/system-design/case-whatsapp.md): System design for a real-time messaging application
- [Data Pipelines](https://resources.devweekends.com/system-design/data-pipelines.md): Designing data processing systems for batch and streaming
- [Database Design](https://resources.devweekends.com/system-design/databases.md): SQL vs NoSQL, Sharding, Replication, and Indexing strategies
- [Distributed Systems](https://resources.devweekends.com/system-design/distributed-systems.md): Consistency, Consensus, and handling failures in distributed systems
- [Back-of-Envelope Calculations](https://resources.devweekends.com/system-design/estimations.md): Essential estimation skills for system design interviews
- [System Design Fundamentals](https://resources.devweekends.com/system-design/fundamentals.md): Core concepts every system designer must know
- [Interview Guide & Cheatsheet](https://resources.devweekends.com/system-design/interview-guide.md): Complete system design interview preparation guide with frameworks, templates, and tips
- [Interview Questions Bank](https://resources.devweekends.com/system-design/interview-questions.md): Common system design interview questions with difficulty levels
- [Microservices Architecture](https://resources.devweekends.com/system-design/microservices.md): Microservices patterns, communication, service mesh, and best practices
- [Networking Fundamentals](https://resources.devweekends.com/system-design/networking.md): Essential networking concepts for system design - DNS, HTTP, TCP/UDP, WebSockets
- [Observability & Monitoring](https://resources.devweekends.com/system-design/observability.md): Building observable systems for production debugging
- [System Design Mastery](https://resources.devweekends.com/system-design/overview.md): Complete system design course for technical interviews - from fundamentals to staff+ level
- [Reliability & Fault Tolerance](https://resources.devweekends.com/system-design/reliability-patterns.md): Building resilient systems that survive failures
- [Scalability Patterns](https://resources.devweekends.com/system-design/scalability-patterns.md): Deep dive into scaling strategies for senior engineers
- [Security Patterns](https://resources.devweekends.com/system-design/security-patterns.md): Building secure systems for production

## OpenAPI Specs

- [openapi](https://resources.devweekends.com/api-reference/openapi.json)

## Optional

- [DevWeekends](https://devweekends.com)