01
Understand the system
Start with the why, the trade-offs, and the mental model behind the code.
Engineering fundamentals, made interactive
DevLoom is where developersunderstand systems, reason through trade-offs, and build with judgment.
Master software development, system design, databases, cloud, and AI through guided lessons, active practice, honest assessments, and real proof of progress.
Stronger fundamentals. Better engineering decisions.
Interactive practiceDurable progressClear next steps
One learning system across the engineering stack
FrontendBackendDatabasesSystem designCloud & DevOpsAI & ML
A better learning loop
Built to create engineering judgment, not passive completion
Every DevLoom surface has one job: move you from seeing a concept to making a sound technical decision with it.
02
Practice the decision
Answer, debug, compare, and apply concepts while the reasoning is still fresh.
03
Prove what changed
Use assessments, projects, progress, and badges to make growth visible.
Structured paths
Go deep without getting lost
DevLoom connects short explanations, active recall, assessments, and practical work so fundamentals compound instead of disappearing after a tutorial.
- Concepts arranged in a deliberate sequence
- Practice attached to the lesson, not left for later
- Progress that survives sessions and devices
- A clear next step instead of another open tab
Browse all courses⚡ 4 comprehensive paths · Interactive learning
Learning bytes
Use five spare minutes without settling for shallow learning
Short, focused explanations reconnect you with one engineering concept at a time, then leave you with a clear path to go deeper.
Bite-sized learning
DSA
Big O Notation: Time & Space Complexity
Big O describes how work grows, not how long it takes. An O(N^2) algorithm on 1,000 items does a million steps; the same work at O(N log N) does about 10,000.
INTERMEDIATE
1 min
Frontend
Data Types in JavaScript: Primitives vs. Objects
Primitives copy by value and objects copy by reference, so b = a duplicates a number but shares an object. That single distinction explains most surprise mutations.
BEGINNER
2 min
Frontend
TypeScript Primitives & Explicit Type Annotations
TypeScript erases entirely at build time, so a string annotation produces no runtime check whatsoever. A value arriving from an API is whatever the server actually sent.
BEGINNER
1 min
Backend
Return the Sum of Two Numbers
A function with no return hands back None, so a forgotten one surfaces as a TypeError at the call site rather than at the line that actually caused it.
BEGINNER
1 min
DSA
Binary Trees & Binary Search Trees (BST)
A BST keeps every left descendant below the node and every right above it. That invariant is what buys O(log N) lookup, and why an unbalanced tree collapses back to O(N).
INTERMEDIATE
1 min
Frontend
Variables: const, let & var (The Box Metaphor)
const prevents reassignment, not mutation: a const object's properties can still be changed. let is scoped to its block, while var is function-scoped and leaks out of loops.
BEGINNER
2 min
Frontend
Type Inference & Literal Types (const vs. let)
let x = 'GET' infers string because the binding can change; const x = 'GET' infers the literal 'GET'. That widening rule is why object properties need as const to stay narrow.
BEGINNER
1 min
Backend
Check if a Number or String is Symmetrical
s[::-1] builds a reversed copy, so comparing it against s is a palindrome test in one expression. It costs O(n) extra memory that two pointers would avoid.
BEGINNER
1 min
DSA
Fast & Slow Pointers (Floyd's Cycle Detection)
Two pointers moving at different speeds must eventually meet inside a loop, the way a faster runner laps a slower one. That detects a cycle in O(N) time and O(1) space.
INTERMEDIATE
1 min
Frontend
Strings & Template Literals `${}`
Only backticks interpolate: ${user} reads the variable, while quotes print literally. Strings are immutable, so every method returns a new one rather than editing in place.
BEGINNER
1 min
Frontend
Arrays, Tuples & Readonly Modifiers
string[] is any number of strings; [string, number] is exactly two, in that order. readonly removes the mutating methods at compile time, so push becomes a type error.
BEGINNER
1 min
Backend
Repeat an Element N Times in a List
[x] * n repeats the reference rather than the object, so [[]] * 3 produces three names for one list. Mutating one changes all three; a comprehension builds distinct objects.
BEGINNER
1 min
DSA
Big O Notation: Time & Space Complexity
Big O describes how work grows, not how long it takes. An O(N^2) algorithm on 1,000 items does a million steps; the same work at O(N log N) does about 10,000.
INTERMEDIATE
1 min
Frontend
Data Types in JavaScript: Primitives vs. Objects
Primitives copy by value and objects copy by reference, so b = a duplicates a number but shares an object. That single distinction explains most surprise mutations.
BEGINNER
2 min
Frontend
TypeScript Primitives & Explicit Type Annotations
TypeScript erases entirely at build time, so a string annotation produces no runtime check whatsoever. A value arriving from an API is whatever the server actually sent.
BEGINNER
1 min
Backend
Return the Sum of Two Numbers
A function with no return hands back None, so a forgotten one surfaces as a TypeError at the call site rather than at the line that actually caused it.
BEGINNER
1 min
DSA
Binary Trees & Binary Search Trees (BST)
A BST keeps every left descendant below the node and every right above it. That invariant is what buys O(log N) lookup, and why an unbalanced tree collapses back to O(N).
INTERMEDIATE
1 min
Frontend
Variables: const, let & var (The Box Metaphor)
const prevents reassignment, not mutation: a const object's properties can still be changed. let is scoped to its block, while var is function-scoped and leaks out of loops.
BEGINNER
2 min
Frontend
Type Inference & Literal Types (const vs. let)
let x = 'GET' infers string because the binding can change; const x = 'GET' infers the literal 'GET'. That widening rule is why object properties need as const to stay narrow.
BEGINNER
1 min
Backend
Check if a Number or String is Symmetrical
s[::-1] builds a reversed copy, so comparing it against s is a palindrome test in one expression. It costs O(n) extra memory that two pointers would avoid.
BEGINNER
1 min
DSA
Fast & Slow Pointers (Floyd's Cycle Detection)
Two pointers moving at different speeds must eventually meet inside a loop, the way a faster runner laps a slower one. That detects a cycle in O(N) time and O(1) space.
INTERMEDIATE
1 min
Frontend
Strings & Template Literals `${}`
Only backticks interpolate: ${user} reads the variable, while quotes print literally. Strings are immutable, so every method returns a new one rather than editing in place.
BEGINNER
1 min
Frontend
Arrays, Tuples & Readonly Modifiers
string[] is any number of strings; [string, number] is exactly two, in that order. readonly removes the mutating methods at compile time, so push becomes a type error.
BEGINNER
1 min
Backend
Repeat an Element N Times in a List
[x] * n repeats the reference rather than the object, so [[]] * 3 produces three names for one list. Mutating one changes all three; a comprehension builds distinct objects.
BEGINNER
1 min
DSA
Big O Notation: Time & Space Complexity
Big O describes how work grows, not how long it takes. An O(N^2) algorithm on 1,000 items does a million steps; the same work at O(N log N) does about 10,000.
INTERMEDIATE
1 min
Frontend
Data Types in JavaScript: Primitives vs. Objects
Primitives copy by value and objects copy by reference, so b = a duplicates a number but shares an object. That single distinction explains most surprise mutations.
BEGINNER
2 min
Frontend
TypeScript Primitives & Explicit Type Annotations
TypeScript erases entirely at build time, so a string annotation produces no runtime check whatsoever. A value arriving from an API is whatever the server actually sent.
BEGINNER
1 min
Backend
Return the Sum of Two Numbers
A function with no return hands back None, so a forgotten one surfaces as a TypeError at the call site rather than at the line that actually caused it.
BEGINNER
1 min
DSA
Binary Trees & Binary Search Trees (BST)
A BST keeps every left descendant below the node and every right above it. That invariant is what buys O(log N) lookup, and why an unbalanced tree collapses back to O(N).
INTERMEDIATE
1 min
Frontend
Variables: const, let & var (The Box Metaphor)
const prevents reassignment, not mutation: a const object's properties can still be changed. let is scoped to its block, while var is function-scoped and leaks out of loops.
BEGINNER
2 min
Frontend
Type Inference & Literal Types (const vs. let)
let x = 'GET' infers string because the binding can change; const x = 'GET' infers the literal 'GET'. That widening rule is why object properties need as const to stay narrow.
BEGINNER
1 min
Backend
Check if a Number or String is Symmetrical
s[::-1] builds a reversed copy, so comparing it against s is a palindrome test in one expression. It costs O(n) extra memory that two pointers would avoid.
BEGINNER
1 min
DSA
Fast & Slow Pointers (Floyd's Cycle Detection)
Two pointers moving at different speeds must eventually meet inside a loop, the way a faster runner laps a slower one. That detects a cycle in O(N) time and O(1) space.
INTERMEDIATE
1 min
Frontend
Strings & Template Literals `${}`
Only backticks interpolate: ${user} reads the variable, while quotes print literally. Strings are immutable, so every method returns a new one rather than editing in place.
BEGINNER
1 min
Frontend
Arrays, Tuples & Readonly Modifiers
string[] is any number of strings; [string, number] is exactly two, in that order. readonly removes the mutating methods at compile time, so push becomes a type error.
BEGINNER
1 min
Backend
Repeat an Element N Times in a List
[x] * n repeats the reference rather than the object, so [[]] * 3 produces three names for one list. Mutating one changes all three; a comprehension builds distinct objects.
BEGINNER
1 min
DSA
Big O Notation: Time & Space Complexity
Big O describes how work grows, not how long it takes. An O(N^2) algorithm on 1,000 items does a million steps; the same work at O(N log N) does about 10,000.
INTERMEDIATE
1 min
Frontend
Data Types in JavaScript: Primitives vs. Objects
Primitives copy by value and objects copy by reference, so b = a duplicates a number but shares an object. That single distinction explains most surprise mutations.
BEGINNER
2 min
Frontend
TypeScript Primitives & Explicit Type Annotations
TypeScript erases entirely at build time, so a string annotation produces no runtime check whatsoever. A value arriving from an API is whatever the server actually sent.
BEGINNER
1 min
Backend
Return the Sum of Two Numbers
A function with no return hands back None, so a forgotten one surfaces as a TypeError at the call site rather than at the line that actually caused it.
BEGINNER
1 min
DSA
Binary Trees & Binary Search Trees (BST)
A BST keeps every left descendant below the node and every right above it. That invariant is what buys O(log N) lookup, and why an unbalanced tree collapses back to O(N).
INTERMEDIATE
1 min
Frontend
Variables: const, let & var (The Box Metaphor)
const prevents reassignment, not mutation: a const object's properties can still be changed. let is scoped to its block, while var is function-scoped and leaks out of loops.
BEGINNER
2 min
Frontend
Type Inference & Literal Types (const vs. let)
let x = 'GET' infers string because the binding can change; const x = 'GET' infers the literal 'GET'. That widening rule is why object properties need as const to stay narrow.
BEGINNER
1 min
Backend
Check if a Number or String is Symmetrical
s[::-1] builds a reversed copy, so comparing it against s is a palindrome test in one expression. It costs O(n) extra memory that two pointers would avoid.
BEGINNER
1 min
DSA
Fast & Slow Pointers (Floyd's Cycle Detection)
Two pointers moving at different speeds must eventually meet inside a loop, the way a faster runner laps a slower one. That detects a cycle in O(N) time and O(1) space.
INTERMEDIATE
1 min
Frontend
Strings & Template Literals `${}`
Only backticks interpolate: ${user} reads the variable, while quotes print literally. Strings are immutable, so every method returns a new one rather than editing in place.
BEGINNER
1 min
Frontend
Arrays, Tuples & Readonly Modifiers
string[] is any number of strings; [string, number] is exactly two, in that order. readonly removes the mutating methods at compile time, so push becomes a type error.
BEGINNER
1 min
Backend
Repeat an Element N Times in a List
[x] * n repeats the reference rather than the object, so [[]] * 3 produces three names for one list. Mutating one changes all three; a comprehension builds distinct objects.
BEGINNER
1 min
DSA
Dynamic Arrays & Amortized Resizing
A dynamic array doubles rather than growing by one, so the expensive copy lands on the 1st, 2nd, 4th and 8th push. Averaged across every push, that is O(1) amortised.
INTERMEDIATE
2 min
Frontend
Numbers, Arithmetic & The Modulo Operator (%)
Every JavaScript number is a 64-bit float, which is why 0.1 + 0.2 comes out as 0.30000000000000004. % returns a remainder that keeps the sign of the left operand.
BEGINNER
2 min
Frontend
Objects & Type Aliases (type Keyword)
? makes a property optional, which adds undefined to its type rather than removing the key. That is why reading it still needs a check even after the shape is declared.
BEGINNER
1 min
Backend
Convert Minutes into Seconds
minutes * 60 returns an int when given an int, while / always produces a float regardless of the operands. Multiplication preserves the type; division does not.
BEGINNER
1 min
DSA
Two Pointers Pattern (Converging & Symmetrical)
A nested loop tests every pair in O(N^2). On sorted data, moving two pointers inward from both ends rules out half the remaining candidates at each step and finishes in O(N).
INTERMEDIATE
1 min
Frontend
Booleans & Truthy vs. Falsy Values
== converts types before comparing, which is how 0 == '' ends up true. === compares type and value together, and that is why it is the default and == the exception.
BEGINNER
2 min
Frontend
Interfaces vs. Type Aliases: When to Use Which
Two interface declarations with the same name merge; two type aliases collide. That single behaviour decides the choice: merging is what makes interfaces right for public APIs.
BEGINNER
1 min
Backend
Calculate the Area of a Triangle
base * height / 2 always yields a float in Python 3 because / never returns an int, even for whole numbers. // floors instead, which is almost never what an area wants.
BEGINNER
1 min
DSA
Sliding Window Pattern (Fixed & Dynamic)
Recomputing each subarray from scratch is O(N^2). A sliding window adds the entering element and subtracts the leaving one, so each step is O(1) and the scan finishes in O(N).
INTERMEDIATE
1 min
Frontend
Making Decisions: if, else & Ternaries
if branches on truthiness rather than equality, so 0, '', null and undefined all take the else path. A ternary evaluates to a value, where if only performs a statement.
BEGINNER
2 min
Frontend
Union Types (|) & Type Narrowing
A union permits only what every member allows, so shared properties are all you can touch. typeof, instanceof and in narrow the union inside a branch, unlocking member shapes.
BEGINNER
1 min
Backend
Return the Next Number from the Integer Passed
Python integers have no fixed width, so n + 1 never overflows the way a 32-bit int would. The value simply grows to whatever memory allows.
BEGINNER
1 min
DSA
Dynamic Arrays & Amortized Resizing
A dynamic array doubles rather than growing by one, so the expensive copy lands on the 1st, 2nd, 4th and 8th push. Averaged across every push, that is O(1) amortised.
INTERMEDIATE
2 min
Frontend
Numbers, Arithmetic & The Modulo Operator (%)
Every JavaScript number is a 64-bit float, which is why 0.1 + 0.2 comes out as 0.30000000000000004. % returns a remainder that keeps the sign of the left operand.
BEGINNER
2 min
Frontend
Objects & Type Aliases (type Keyword)
? makes a property optional, which adds undefined to its type rather than removing the key. That is why reading it still needs a check even after the shape is declared.
BEGINNER
1 min
Backend
Convert Minutes into Seconds
minutes * 60 returns an int when given an int, while / always produces a float regardless of the operands. Multiplication preserves the type; division does not.
BEGINNER
1 min
DSA
Two Pointers Pattern (Converging & Symmetrical)
A nested loop tests every pair in O(N^2). On sorted data, moving two pointers inward from both ends rules out half the remaining candidates at each step and finishes in O(N).
INTERMEDIATE
1 min
Frontend
Booleans & Truthy vs. Falsy Values
== converts types before comparing, which is how 0 == '' ends up true. === compares type and value together, and that is why it is the default and == the exception.
BEGINNER
2 min
Frontend
Interfaces vs. Type Aliases: When to Use Which
Two interface declarations with the same name merge; two type aliases collide. That single behaviour decides the choice: merging is what makes interfaces right for public APIs.
BEGINNER
1 min
Backend
Calculate the Area of a Triangle
base * height / 2 always yields a float in Python 3 because / never returns an int, even for whole numbers. // floors instead, which is almost never what an area wants.
BEGINNER
1 min
DSA
Sliding Window Pattern (Fixed & Dynamic)
Recomputing each subarray from scratch is O(N^2). A sliding window adds the entering element and subtracts the leaving one, so each step is O(1) and the scan finishes in O(N).
INTERMEDIATE
1 min
Frontend
Making Decisions: if, else & Ternaries
if branches on truthiness rather than equality, so 0, '', null and undefined all take the else path. A ternary evaluates to a value, where if only performs a statement.
BEGINNER
2 min
Frontend
Union Types (|) & Type Narrowing
A union permits only what every member allows, so shared properties are all you can touch. typeof, instanceof and in narrow the union inside a branch, unlocking member shapes.
BEGINNER
1 min
Backend
Return the Next Number from the Integer Passed
Python integers have no fixed width, so n + 1 never overflows the way a 32-bit int would. The value simply grows to whatever memory allows.
BEGINNER
1 min
DSA
Dynamic Arrays & Amortized Resizing
A dynamic array doubles rather than growing by one, so the expensive copy lands on the 1st, 2nd, 4th and 8th push. Averaged across every push, that is O(1) amortised.
INTERMEDIATE
2 min
Frontend
Numbers, Arithmetic & The Modulo Operator (%)
Every JavaScript number is a 64-bit float, which is why 0.1 + 0.2 comes out as 0.30000000000000004. % returns a remainder that keeps the sign of the left operand.
BEGINNER
2 min
Frontend
Objects & Type Aliases (type Keyword)
? makes a property optional, which adds undefined to its type rather than removing the key. That is why reading it still needs a check even after the shape is declared.
BEGINNER
1 min
Backend
Convert Minutes into Seconds
minutes * 60 returns an int when given an int, while / always produces a float regardless of the operands. Multiplication preserves the type; division does not.
BEGINNER
1 min
DSA
Two Pointers Pattern (Converging & Symmetrical)
A nested loop tests every pair in O(N^2). On sorted data, moving two pointers inward from both ends rules out half the remaining candidates at each step and finishes in O(N).
INTERMEDIATE
1 min
Frontend
Booleans & Truthy vs. Falsy Values
== converts types before comparing, which is how 0 == '' ends up true. === compares type and value together, and that is why it is the default and == the exception.
BEGINNER
2 min
Frontend
Interfaces vs. Type Aliases: When to Use Which
Two interface declarations with the same name merge; two type aliases collide. That single behaviour decides the choice: merging is what makes interfaces right for public APIs.
BEGINNER
1 min
Backend
Calculate the Area of a Triangle
base * height / 2 always yields a float in Python 3 because / never returns an int, even for whole numbers. // floors instead, which is almost never what an area wants.
BEGINNER
1 min
DSA
Sliding Window Pattern (Fixed & Dynamic)
Recomputing each subarray from scratch is O(N^2). A sliding window adds the entering element and subtracts the leaving one, so each step is O(1) and the scan finishes in O(N).
INTERMEDIATE
1 min
Frontend
Making Decisions: if, else & Ternaries
if branches on truthiness rather than equality, so 0, '', null and undefined all take the else path. A ternary evaluates to a value, where if only performs a statement.
BEGINNER
2 min
Frontend
Union Types (|) & Type Narrowing
A union permits only what every member allows, so shared properties are all you can touch. typeof, instanceof and in narrow the union inside a branch, unlocking member shapes.
BEGINNER
1 min
Backend
Return the Next Number from the Integer Passed
Python integers have no fixed width, so n + 1 never overflows the way a 32-bit int would. The value simply grows to whatever memory allows.
BEGINNER
1 min
DSA
Dynamic Arrays & Amortized Resizing
A dynamic array doubles rather than growing by one, so the expensive copy lands on the 1st, 2nd, 4th and 8th push. Averaged across every push, that is O(1) amortised.
INTERMEDIATE
2 min
Frontend
Numbers, Arithmetic & The Modulo Operator (%)
Every JavaScript number is a 64-bit float, which is why 0.1 + 0.2 comes out as 0.30000000000000004. % returns a remainder that keeps the sign of the left operand.
BEGINNER
2 min
Frontend
Objects & Type Aliases (type Keyword)
? makes a property optional, which adds undefined to its type rather than removing the key. That is why reading it still needs a check even after the shape is declared.
BEGINNER
1 min
Backend
Convert Minutes into Seconds
minutes * 60 returns an int when given an int, while / always produces a float regardless of the operands. Multiplication preserves the type; division does not.
BEGINNER
1 min
DSA
Two Pointers Pattern (Converging & Symmetrical)
A nested loop tests every pair in O(N^2). On sorted data, moving two pointers inward from both ends rules out half the remaining candidates at each step and finishes in O(N).
INTERMEDIATE
1 min
Frontend
Booleans & Truthy vs. Falsy Values
== converts types before comparing, which is how 0 == '' ends up true. === compares type and value together, and that is why it is the default and == the exception.
BEGINNER
2 min
Frontend
Interfaces vs. Type Aliases: When to Use Which
Two interface declarations with the same name merge; two type aliases collide. That single behaviour decides the choice: merging is what makes interfaces right for public APIs.
BEGINNER
1 min
Backend
Calculate the Area of a Triangle
base * height / 2 always yields a float in Python 3 because / never returns an int, even for whole numbers. // floors instead, which is almost never what an area wants.
BEGINNER
1 min
DSA
Sliding Window Pattern (Fixed & Dynamic)
Recomputing each subarray from scratch is O(N^2). A sliding window adds the entering element and subtracts the leaving one, so each step is O(1) and the scan finishes in O(N).
INTERMEDIATE
1 min
Frontend
Making Decisions: if, else & Ternaries
if branches on truthiness rather than equality, so 0, '', null and undefined all take the else path. A ternary evaluates to a value, where if only performs a statement.
BEGINNER
2 min
Frontend
Union Types (|) & Type Narrowing
A union permits only what every member allows, so shared properties are all you can touch. typeof, instanceof and in narrow the union inside a branch, unlocking member shapes.
BEGINNER
1 min
Backend
Return the Next Number from the Integer Passed
Python integers have no fixed width, so n + 1 never overflows the way a 32-bit int would. The value simply grows to whatever memory allows.
BEGINNER
1 min
The DevLoom toolkit
A learning system that stays useful after the lesson
Start with a clear explanation, practice it, check your understanding, and keep moving with a next step that makes sense.
Courses & Career Paths
Learn with structured interactive engineering courses
Go deep from first principles with interactive lessons, code exercises, and real-world system challenges.
Assessments
Get customized engineering skill recommendations
Check your understanding across core systems, benchmark gaps with skill graphs, and get targeted next steps.
Connected Ecosystem
One continuous loop from theory to proof of work
Seamlessly navigate courses, hands-on bytes, system assessments, and verified milestones without friction.
Tutorials
Step-by-step guides crafted by seasoned engineers
Follow real-world system design breakdowns, high-concurrency architectures, and production code walkthroughs.
Glossary
Every engineering concept, explained from first principles
Demystify distributed systems, low-level concurrency, database internals, and algorithms with clear mental models.
Learning Bytes
Bite-sized visual drills you can solve in 2 minutes
Sharpen mental models, master subtle language mechanics, and spot insidious production bugs in quick daily interactive bursts.
“If you can explain why a system works, compare its trade-offs, and make the next decision with confidence, the learning worked.”
The DevLoom learning principle
How DevLoom works
A clear path from curiosity to capability
Find the right concept, work through the reasoning, and leave with progress you can return to and prove.
Find the right starting point
Explore structured paths, focused learning bytes, and assessments without opening another maze of tabs.
Work through the reasoning
Learn the mental model, test the trade-offs, and practice while the concept is still fresh.
Turn effort into proof
Keep durable progress, honest skill reports, badges, and projects in one developer profile.
Learn in the format that fits
Start where you are. Keep the next step clear.
You do not need one giant curriculum to make progress. DevLoom gives you a few clear ways to learn: go deep with a course, understand one small idea, follow a tutorial, or check yourself.
01
Courses
Take one subject in sequence, with lessons that build on the idea before them.
For focused, structured study
02
Learning Bytes
Use a few spare minutes to understand one engineering concept clearly.
For a useful reset between tasks
03
Tutorials
Follow a complete explanation when you want the why, not just the steps.
For practical, guided understanding
04
Assessments
Check what you understand, then use the result to choose a sensible next topic.
For an honest check-in
Choose the format that helps with the question in front of you, then take the next step when you are ready.
Explore learning
Start with the fundamentals
Stop collecting tutorials. Start building engineering judgment.
Choose a path, practice the hard parts, and keep your progress in one place.