AWS RDS Basics: Managed Relational Databases
A practical introduction to Amazon RDS: supported engines, instance types, backups and snapshots, multi-AZ deployments, parameter groups, and security.
·6 min read · #aws#rds#intermediate
#intermediate
442 posts · page 6 of 10
AWS VPC Basics: Subnets, Route Tables, and Gateways
Understand AWS VPC fundamentals: public vs private subnets, internet and NAT gateways, route tables, and the difference between security groups and NACLs.
·7 min read · #aws#vpc#intermediate
C++ Classes, Constructors, and the Rule of Three
Design C++ classes with constructors, destructors, member initializer lists, and the Rule of Three and Five to manage resources safely.
·5 min read · #cpp#oop#intermediate
Modern C++ Features You Should Use: auto, range-for, structured bindings
Tour the modern C++ features that pay back every day: auto, range-for, structured bindings, if-init, std::optional, and string_view.
·5 min read · #cpp#modern#intermediate
C++ Pointers and Manual Memory Basics
Learn C++ pointers, the stack vs the heap, new and delete, nullptr, pointer arithmetic, and why modern C++ pushes you toward smart pointers.
·6 min read · #cpp#pointers#intermediate
Modern C++ Smart Pointers: unique_ptr and shared_ptr
Use unique_ptr, shared_ptr, and weak_ptr to model ownership in modern C++ without manual new and delete or memory leaks.
·5 min read · #cpp#memory#intermediate
C++ STL Containers: vector, map, set, unordered_map
Pick the right C++ STL container for the job: vector, deque, list, map, set, unordered_map, and unordered_set with their complexity guarantees.
·5 min read · #cpp#stl#intermediate
C++ Templates: Generics That Compile to Specifics
Learn C++ templates from scratch: function templates, class templates, type deduction, specialization, and how the compiler stamps out concrete code.
·5 min read · #cpp#templates#intermediate
ArgoCD and GitOps for Kubernetes
ArgoCD makes Git the source of truth for your Kubernetes clusters. Learn the GitOps pattern, the App-of-Apps model, and sync strategies that work.
·6 min read · #argocd#gitops#intermediate
GitHub Actions Matrix Builds: Test Across Versions
Use the matrix strategy in GitHub Actions to test across Node versions, operating systems, and dependency sets without duplicating workflow files.
·5 min read · #github-actions#ci#intermediate
NGINX as a Reverse Proxy: Configuration That Works
Set up NGINX as a reverse proxy for Node, Python, or container backends with the right headers, timeouts, and TLS configuration for production.
·6 min read · #nginx#networking#intermediate
Terraform Basics: HCL, Providers, and Your First Resource
Learn the foundations of Terraform: writing HCL, configuring providers, managing state, and creating your first cloud resource the right way.
·5 min read · #terraform#iac#intermediate
Docker Networking Basics: Bridges, Ports, and DNS
A practical guide to Docker networking: the default bridge, user-defined bridges, host networking, container DNS, and how port publishing actually works.
·6 min read · #docker#networking#intermediate
Backtracking Patterns: Subsets, Permutations, N-Queens
A practical guide to backtracking: the recursion template, pruning, classic problems with code, and complexity analysis for subsets and permutations.
·6 min read · #dsa#backtracking#intermediate
Bellman-Ford and Negative-Weight Edges
Understand Bellman-Ford's relaxation loop, how it handles negative edges, detects negative cycles, and why it costs more than Dijkstra.
·5 min read · #graphs#shortest-path#intermediate
Dijkstra's Algorithm: Shortest Paths Explained
Learn Dijkstra's shortest path algorithm with a clean Python implementation, complexity analysis, and the priority queue intuition behind it.
·5 min read · #graphs#shortest-path#intermediate
Divide and Conquer: Mental Model with Merge Sort and Quick Sort
Learn the divide-and-conquer pattern through merge sort and quick sort, recurrence relations, the Master theorem, and how to recognize the pattern.
·7 min read · #dsa#divide-and-conquer#intermediate
Fenwick Tree (BIT): Prefix Sums on the Cheap
Implement and understand the Fenwick tree, also called the binary indexed tree, for O(log n) prefix sums and point updates in just a few lines.
·6 min read · #data-structures#fenwick-tree#intermediate
Kruskal's and Prim's MST Algorithms
Build minimum spanning trees with Kruskal's union-find approach and Prim's priority queue approach, with side-by-side Python implementations.
·5 min read · #graphs#mst#intermediate
3Sum — Sort and Two Pointers, Step by Step
A careful walkthrough of 3Sum using sort plus two pointers. We handle duplicate triplets cleanly and avoid the classic off-by-one traps.
·7 min read · #dsa#leetcode#two-pointers
Binary Tree Level Order Traversal — Queue Size Snapshot
The queue-with-size BFS pattern, why DFS still works, and how this template extends to zigzag and right-side view.
·5 min read · #dsa#leetcode#trees
Climbing Stairs: Fibonacci in Disguise
Walk through Climbing Stairs from brute force recursion to bottom-up DP, with edge cases, complexity analysis, and an interview script.
·5 min read · #dsa#leetcode#dynamic-programming
Clone Graph — DFS With a Node-to-Copy Hash Map
Why a hash map from original to copy is the entire idea, plus the BFS variant for stack-limited environments.
·5 min read · #dsa#leetcode#graphs
Coin Change: Bottom-Up DP Explained
Walk through Coin Change with brute force recursion, memoization, and bottom-up DP. Includes complexity analysis and interview script.
·6 min read · #dsa#leetcode#dynamic-programming
Container With Most Water — Two-Pointer Walkthrough
Solve Container With Most Water with the two-pointer technique. We prove correctness and contrast it with the quadratic brute force.
·6 min read · #dsa#leetcode#two-pointers
Combination Sum: Backtracking With Reuse
Solve Combination Sum with a clean backtracking template. Pruning, duplicate avoidance, complexity discussion, and interview script.
·5 min read · #dsa#leetcode#backtracking
Course Schedule — Topological Sort With DFS
Detect cycles and produce a valid course order using DFS-based topological sort. Includes BFS Kahn alternative and interview script.
·6 min read · #dsa#leetcode#graphs
Edit Distance: 2D DP Step by Step
Edit Distance fully unpacked — the three-operation recurrence, the 2D table, and the rolling-array space optimization that makes interviewers nod.
·6 min read · #dsa#leetcode#dp
Daily Temperatures — Monotonic Stack Pattern
Solve Daily Temperatures with a monotonic decreasing stack of indices. Includes brute force comparison, walkthrough, complexity, and interview tips.
·6 min read · #dsa#leetcode#stack
Group Anagrams — Hash Map of Canonical Keys
Solve the Group Anagrams problem cleanly with a hash map keyed by sorted strings or character counts. Includes complexity analysis and interview talking points.
·6 min read · #dsa#leetcode#hashing
Generate Parentheses: Counting Backtrack
Solve Generate Parentheses with counting-based backtracking. Clean invariant, walkthrough, complexity discussion, and interview tips.
·4 min read · #dsa#leetcode#backtracking
House Robber: The Pick-or-Skip DP Template
Solve House Robber with the pick-or-skip DP recurrence, then optimize to O(1) space. Includes interview script and related variants.
·5 min read · #dsa#leetcode#dynamic-programming
Invert Binary Tree — Recursive Mirror Swap
Solve Invert Binary Tree with a four-line recursive swap and an iterative BFS alternative, including complexity and interview talking points.
·5 min read · #dsa#leetcode#binary-tree
Kth Smallest Element in a BST — Iterative Inorder Early Exit
The inorder traversal trick, the iterative early-exit version, and the follow-up that haunts FAANG interviews.
·5 min read · #dsa#leetcode#trees
Letter Combinations of a Phone Number: Index Backtracking
Solve Letter Combinations of a Phone Number with backtracking. Mapping setup, recursive enumeration, complexity, and interview walkthrough.
·5 min read · #dsa#leetcode#backtracking
Longest Consecutive Sequence — The Hash Set Trick
Solve Longest Consecutive Sequence in O(n) using a hash set and a start-of-run check. Walkthrough, edge cases, and interview script.
·5 min read · #dsa#leetcode#hashing
Longest Increasing Subsequence: DP and Patience
Longest Increasing Subsequence in detail — the O(n^2) DP, the O(n log n) patience-sorting trick with binary search, and when each one matters.
·6 min read · #dsa#leetcode#dp
Longest Palindromic Substring — Expand Around Center
Walk through the Longest Palindromic Substring problem using the expand-around-center technique. Compare brute force, DP, and the optimal approach with examples.
·7 min read · #dsa#leetcode#strings
LRU Cache — Hash Map + Doubly Linked List
Design LRU Cache with a hash map and a doubly linked list to get O(1) get and put, with a clean implementation and interview tips.
·6 min read · #dsa#leetcode#design
Longest Substring Without Repeating Characters — Sliding Window
Solve Longest Substring Without Repeating Characters using a sliding window with a hash map. We go from brute force to a clean O(n) sweep.
·5 min read · #dsa#leetcode#sliding-window
Lowest Common Ancestor of a BST — One-Line Guided Walk
Why BST ordering collapses LCA into a one-line traversal, and the iterative version that needs zero extra space.
·5 min read · #dsa#leetcode#trees
Maximum Depth of Binary Tree — DFS in Three Lines
Compute tree depth with a three-line recursive DFS and an iterative BFS alternative, with complexity analysis and interview tips.
·5 min read · #dsa#leetcode#binary-tree
Maximum Subarray — Kadane's Algorithm Explained
A clear walkthrough of Maximum Subarray. We build Kadane's algorithm from first principles and contrast it with the divide and conquer approach.
·5 min read · #dsa#leetcode#arrays
Min Stack — Track Mins in O(1)
Design a stack that supports push, pop, top, and getMin in constant time. Walkthrough of the two-stack and pair-stack solutions with edge cases and interview tips.
·5 min read · #dsa#leetcode#stack
Number of Islands — Grid DFS Flood Fill
Solve Number of Islands with grid DFS and BFS, including a union-find variant, edge-case handling, and clear interview talking points.
·6 min read · #dsa#leetcode#graph
Merge Two Sorted Lists — The Dummy-Head Pattern
Solve Merge Two Sorted Lists with the dummy-head pointer pattern, plus a recursive variant, edge cases, and interview explanation tips.
·5 min read · #dsa#leetcode#linked-list
Pacific Atlantic Water Flow — Flood Inward From the Borders
Why reverse traversal beats per-cell flood fill, and how the intersection of two reach sets gives the answer.
·7 min read · #dsa#leetcode#graphs
Path Sum — DFS With a Running Target
The DFS-with-decrement trick, why the leaf condition is the whole problem, and the variants that build on it.
·5 min read · #dsa#leetcode#trees