Decoded update — here’s what’s new

Sreya Satheesh — Fri, 17 Apr 2026 06:00:20 +0000

When I first built Decoded, the goal was simple:

Make DSA easier to understand through step-by-step visual thinking instead of memorization.

But as the platform evolved, a few gaps became more obvious — mainly around consistency, completeness, and how smoothly you move between topics.

This update is focused on that.

Data Structures section expanded

Added a few core structures that were missing earlier but show up very frequently in problem solving.

Earlier, the section covered basics well, but felt slightly incomplete when connecting it to patterns and interview-style problems.

This fills that gap.

Patterns section is now more consistent

Patterns were already there, but the structure wasn’t fully uniform across pages.

That’s been standardized.

Now every pattern follows the same flow:

what the pattern solves
how to think about it (approach)
types
list of problems under it

👉 https://decoded-app.com/patterns

Two new visual problems added

Added two more step-by-step visual problems into the system.

Minimum Size Subarray Sum

👉 https://decoded-app.com/visualizer/minimum-size-subarray-sum

Sliding window problem.

Flow:

window expands as elements are added
condition becomes valid
window shrinks to minimize the answer
best result is tracked step by step

Focus here is on making the expand/shrink behavior actually visible.

Number of Islands

👉 https://decoded-app.com/visualizer/number-of-islands

Grid traversal using DFS / BFS.

Flow:

a land cell triggers traversal
search spreads to connected cells
visited cells prevent revisits
each island is fully explored before moving on

This helps make graph traversal feel less abstract and more visual.

That’s the update for now. :)

👉 https://decoded-app.com/

Decoded — a simple way to actually understand DSA

Sreya Satheesh — Mon, 13 Apr 2026 06:35:09 +0000

👉https://decoded-app.com/

When you're learning DSA, there’s a point where things start feeling repetitive.

You solve problems.
You look at solutions.
You understand them.

But a few days later, the same type of problem feels new again.

That usually happens because you're remembering solutions, not the thinking behind them.

Decoded is a small web app built to fix that.

What Decoded tries to do

The goal is pretty simple:

Make it easier to understand how to approach problems — not just how to code the solution.

Instead of dumping answers, it focuses on:

breaking problems down
showing how the solution evolves
helping you recognize patterns

Inside the app

Problems with step-by-step thinking

Each problem comes with:

a clear explanation
a structured approach
a step-by-step dry run

The dry run is the important part.

You can actually follow:

how variables change
how pointers move
how the solution builds up

So you can see everything happen instead of imagining it.

Complexity

Every solution includes:

time complexity
space complexity

But instead of just stating Big-O, the focus is on why it’s that value.

Patterns

One of the most useful sections is the Patterns page.

A lot of DSA problems aren’t unique — they’re variations of a few common ideas.

This page groups problems based on patterns like:

two pointers
sliding window
prefix sum

Each pattern explains:

how it works
when to use it
what kind of problems it fits

Over time, you stop thinking “I’ve seen this before”
and start thinking “this looks like a sliding window problem.”

That’s a big difference.

Data Structures

The Data Structures page focuses on fundamentals.

It covers things like:

arrays
linked lists
stacks
queues

The idea isn’t to go deep into theory, but to keep it practical.

Each structure is explained in terms of:

what it does
how it behaves
where it’s useful

So instead of just knowing definitions, you start understanding when to use what.

Who this is for

beginners starting DSA
people preparing for interviews

Forem: Sreya Satheesh