She Leads Tech
Practices
Fortnightly live LeetCode and problem-solving workshops designed to build coding confidence, master algorithmic patterns, and ace technical interviews together.

Build your problem-solving habit together
Two Pointers & In-Place Array Transformations
Interactive collaborative live coding session. We break down the algorithmic pattern, code the solution together step-by-step, and practice mock technical interview discussions in a supportive peer space.
✨ Free, safe & inclusive environment. Guided by our Code of Conduct.
// Problem: Two Sum / Two Pointers Approach
// Time Complexity: O(n) | Space Complexity: O(1)
function twoSumSorted(numbers: number[], target: number): number[] {
let left = 0;
let right = numbers.length - 1;
while (left < right) {
const sum = numbers[left] + numbers[right];
if (sum === target) {
return [left + 1, right + 1]; // Found match!
} else if (sum < target) {
left++; // Need a larger value
} else {
right--; // Need a smaller value
}
}
return [];
}Master Patterns,
Not Just Solutions
Memorizing thousands of LeetCode problems doesn't work. In our sessions, we focus on identifying the core mental models so you can solve novel problems on the spot during technical interviews.
Dissect Time & Space Trade-offs
Learn how to articulate Big-O bounds confidently to interviewers.
Pair Programming Dynamics
Collaborate with peers, practice thinking out loud, and overcome interview anxiety.
Essential Interview Patterns We Cover
We cycle through fundamental algorithmic patterns every two weeks so you gain broad, practical mastery.
Two Pointers & Sliding Window
Optimising subarray lookups and in-place array transformations from O(n²) to O(n).
Trees & Binary Search Trees
Mastering recursion, DFS, BFS level-order traversal, and tree validations.
Hash Maps & Frequency Tables
Instant O(1) lookups, anagram detection, prefix sums, and two-sum patterns.
Graphs & Matrix Traversal
Island counts, flood fill, shortest path algorithms, and topological sorting.
Dynamic Programming & Memoization
Breaking complex optimization challenges down into reusable subproblems.
How a Typical 70-Minute Practice Runs
Every session is structured to maximize active coding time and mutual support.
Problem Deconstruction
15 Minutes
We review the problem statement together, clarify edge cases, identify input constraints, and brainstorm brute-force approaches.
Live Group Coding
35 Minutes
We work through the problem and build the solution together as a group in real time, testing edge cases and refining logic collaboratively.
Debrief & Tips
20 Minutes
We review clean code patterns, discuss time/space complexity optimizations, and share real interview tips.
Why Engineers Love Practicing With Us
Solve LeetCode-Style Problems
Hands-on practice tackling curated algorithmic challenges in real time.
Collaborate & Discuss Approaches
Work together as a whole group to share ideas, clean code, and edge cases in real time.
Master Interview Patterns
Recognize patterns like Two Pointers, Sliding Window, Trees & Graphs quickly.
Ask Questions Freely
Safe, supportive space where no question is too basic and curiosity is celebrated.
Build Interview Confidence
Overcome interview anxiety with regular, structured practice among peers.
Inclusive & Supportive
We encourage a friendly, inclusive environment where learning together matters far more than finding the perfect solution on the first try.
Simple Prerequisites
A free LeetCode account
For attempting problems during live sessions.
Basic JavaScript or TypeScript
Familiarity with loops, functions, and arrays.
Curiosity & Collaboration
Willingness to learn together and support peers.
🛡️ Safe & Supportive Space: All attendees and mentors uphold our Community Guidelines & Code of Conduct.
Progressive Skill Growth
This is an ongoing series held every two weeks. We start with Easy and Medium problems, gradually progressing to harder challenges as we build our skills together.
Never Miss an Episode
Subscribe on your favourite platform and get notified the moment a new episode drops each month.