DEV Community: Sreya Satheesh

Behind Every 429 Too Many Requests

Sreya Satheesh — Thu, 18 Jun 2026 08:05:53 +0000

👉 https://rate-limiter-two.vercel.app/

Most developers have seen this message before:

429 Too Many Requests

A request gets rejected because a limit has been reached.

But what actually happens behind the scenes?

How does the system know you've made too many requests?

Where are those requests counted?

What happens when millions of users are sending requests at the same time?

Those questions got me interested in rate limiter design.

What Is a Rate Limiter?

A rate limiter controls how many requests a user, client, or service can make within a given period of time.

You'll find them almost everywhere:

APIs
Authentication systems
Payment services
AI applications
Public platforms

Without rate limiting, a single user or script could overwhelm a system with requests.

Why Does Designing One Matter?

A simple rate limiter might work for a small application.

Things become more interesting when the traffic grows.

Where should request counts be stored?

How much data needs to be maintained?

How many requests should the system handle every second?

How do multiple servers share the same limits?

Answering those questions is where system design comes in.

Breaking Down the Design

The project covers the different stages involved in designing a rate limiter:

Functional Requirements
Non-Functional Requirements
Capacity Estimation
High-Level Design

Each section builds on the previous one.

Requirements influence the scale.

Scale influences the architecture.

And the architecture influences the implementation choices.

High-Level Design

Once the requirements and scale are clear, the architecture becomes much easier to understand.

The High-Level Design section explains the major components involved and how requests move through the system.

What's Next?

Algorithms and race conditions are currently being added.

Future updates will cover:

Fixed Window
Sliding Window
Token Bucket
Leaky Bucket
Distributed rate limiting challenges

👉 https://rate-limiter-two.vercel.app/

What If DSA Was Taught Visually Instead of Just Theory?

Sreya Satheesh — Thu, 11 Jun 2026 05:45:07 +0000

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

When learning DSA, it's easy to fall into a familiar cycle.

You solve a problem, understand the solution, and move on.

A few days later, you come across a similar problem—and suddenly it feels unfamiliar again.

The frustrating part is that you did understand the solution.

What often doesn't stick is the reasoning behind it.

How do you know where to start?

How do you recognize patterns?

How do you arrive at an efficient approach before writing any code?

Those questions are what led me to build Decoded.

What is Decoded?

Decoded is a small app focused on helping people understand how DSA problems are approached, not just how they're solved.

Instead of jumping straight to the final solution, it breaks problems down step by step.

The goal is to show:

how you begin thinking about a problem
how patterns start becoming visible
how an approach gradually forms
and how the final solution evolves from there

Rather than memorizing answers, the focus is on understanding the path that leads to them.

See Algorithms in Action

One feature I found especially useful while learning was seeing algorithms unfold visually.

So Decoded includes step-by-step dry runs that show how variables, pointers, and state change throughout execution.

For example, in the Longest Substring Without Repeating Characters problem, you can watch the sliding window expand and shrink as duplicate characters are encountered.

" width="800" height="373">

Instead of reading through a static explanation, you can follow the algorithm's behavior step by step and see exactly why each decision is made.

The goal is to make the process feel less abstract and easier to follow.

Learning Patterns Instead of Memorizing Problems

One thing I noticed while studying DSA is that most problems aren't completely unique.

Many of them are variations of a handful of recurring patterns:

Sliding Window
Two Pointers
Prefix Sum
DFS / BFS
Heaps
Dynamic Programming and more

" width="799" height="370">

Once you start recognizing these patterns, solving problems becomes much easier.

You're no longer starting from scratch every time.

Instead, you're identifying familiar structures and applying ideas you've seen before.

Decoded tries to make those patterns easier to spot through visual explanations and guided breakdowns.

For example, the Two Pointers section shows how pointers move through an array, when they move, why they move, and which types of interview problems commonly rely on the technique.

Understanding Data Structures

Alongside problem-solving patterns, I also added short explanations for common data structures:

Arrays
Stacks
Queues
Trees
Graphs
Heaps
Hash Maps

The goal isn't to provide a deep theoretical reference.

It's simply to help answer a few practical questions:

How does this data structure behave?
When should I use it?
Why does it appear so often in coding interviews?

For example, you can visualize how array operations work and compare approaches like linear search and binary search to better understand their trade-offs.

Why I Built It

The idea behind Decoded is simple.

I wanted a resource that focused less on memorizing solutions and more on understanding how solutions are discovered.

Something that makes algorithms feel a little less intimidating and a little more intuitive.

It's not meant to replace practice.

It's meant to make the reasoning behind problems easier to see.

If you're currently learning DSA and want a more visual, step-by-step approach, you can try it here:

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

How I Built a Malayalam Learning App as a Tribute to My Mother Tongue

Sreya Satheesh — Tue, 12 May 2026 08:35:56 +0000

I enjoy learning languages.

Growing up in Kerala, Malayalam was always around me.

At some point, I started wondering what it would feel like to build something that helps people learn Malayalam.

That idea eventually became Aksharam — a simple Malayalam learning app designed to help beginners learn the language.

Aksharam (അക്ഷരം) means letter in Malayalam.

The goal of the app is simple: help beginners learn Malayalam step by step, from individual letters to words and sentences.

What Aksharam Includes

The app currently includes:

സ്വരാക്ഷരങ്ങൾ (Vowels)
വ്യഞ്ജനങ്ങൾ (Consonants)
ചില്ലക്ഷരങ്ങൾ (Chillu Letters)
കൂട്ടക്ഷരങ്ങൾ (Compound Letters)
സ്വരചിഹ്നങ്ങൾ (Signs & Combinations)
വാക്കുകൾ (Words)
വാക്യങ്ങൾ (Sentences)

Each lesson includes audio pronunciation support and English transliteration to make learning easier for beginners.

The app is designed primarily for people who are new to Malayalam—whether they're language enthusiasts, students, members of the Malayalam diaspora, or simply curious about learning the language.

Keeping the Learning Process Simple

While building Aksharam, I wanted the experience to feel simple, clean, and easy to follow.

Learning a language takes time. It's less about memorizing everything at once and more about becoming familiar with the language through repetition and practice.

Instead of trying to include too many features, I focused on smaller learning steps and everyday vocabulary that learners are likely to encounter early on.

The goal was to create something approachable rather than overwhelming.

Why I Built It

This project started as a way to explore language learning, but it gradually became something more personal.

Malayalam is a language I grew up hearing every day.

Building Aksharam gave me an opportunity to contribute something back to it in a small way.

It's still a work in progress, and there are plenty of things I'd like to improve.

But I'm happy to finally share it.

If you'd like to explore the language or know someone who might benefit from it, you can try Aksharam here:

https://aksharam-app.vercel.app/