The Habit of Thinking in Edge Cases

●2 ●23 ●87
calendar_today • schedule12 min read

There is a particular moment in programming when everything seems to work.

The application starts.

The buttons respond.

The API returns the expected JSON.

The database contains exactly what you expected.

The test passes.

You look at the screen and think:

It works.

And sometimes, it does.

But software has a strange personality.

It rarely breaks where we expect it to break.

The obvious path is usually the easiest path.

A user enters a normal email address.

A customer buys one product.

A payment succeeds.

A file exists.

A database query returns a result.

A list contains ten items.

A username has an ordinary number of characters.

A network request completes in a reasonable amount of time.

Everything looks comfortable.

Then reality arrives.

Someone uploads an empty file.

Someone clicks a button twice.

Someone submits a form with spaces instead of text.

Someone's name contains an unusual character.

Someone has 0 items in their shopping cart.

Someone has 10,000.

The network disappears halfway through a request.

The database returns nothing.

A timestamp crosses midnight.

A number becomes larger than expected.

A user opens the same account on two devices.

A request arrives twice.

And suddenly, the application discovers a world that was never represented in the original design.

This is where edge cases live.

They are the strange little corners of a system that don't appear in the happy path.

And learning to think about them is one of the most useful habits a programmer can develop.


The Happy Path Is Only the Beginning

Most applications are initially imagined through happy paths.

You describe the normal journey:

User → Login → Dashboard → Create Item → Save → Success

It is clean.

It is easy to understand.

It is also incomplete.

A real system might experience:

User → Login → Wrong Password
User → Login → Network Failure
User → Login → Expired Session
User → Login → Locked Account
User → Login → Duplicate Request
User → Login → Unexpected Input

The happy path describes what happens when everything goes correctly.

Edge-case thinking asks a different question:

What happens when something slightly unusual happens?

Notice the word "slightly."

An edge case doesn't have to be catastrophic.

Sometimes it is simply something the developer didn't imagine.

A shopping cart with zero products.

A page with exactly one result.

A page with 10,001 results.

A string containing one character.

A string containing 10,000 characters.

A user who has never completed an action.

A user who has completed it 1,000 times.

These situations are not necessarily abnormal.

They are simply less common.

And software has to deal with both common and uncommon states.


Edge Cases Are Where Assumptions Become Visible

Every application contains assumptions.

Some are written down.

Many are not.

You might write:

const firstUser = users[0];

That line quietly assumes something.

It assumes users exists.

It assumes users is an array.

It assumes the array contains at least one element.

The code may work perfectly for months.

Then an empty database query returns:

[]

And suddenly:

users[0]

isn't a user.

It is undefined.

The interesting part is not the bug itself.

The interesting part is the hidden assumption.

Good engineering often means discovering these assumptions before production does it for you.

Instead of asking only:

"Does this work?"

we start asking:

"What does this code assume?"

That question opens an entirely different way of looking at software.


The Edge of a Number

Numbers are particularly good at exposing assumptions.

Consider:

discount = price * percentage

It looks harmless.

But what values can percentage contain?

What about:

0
1
50
100
-10
150
0.5

What does the application consider valid?

Now consider quantities.

1 item
10 items
100 items
0 items
-1 items

The interesting cases often live around the boundaries.

If the valid range is:

1–100

then the most interesting values are often:

0
1
2
99
100
101

This is why boundary-value testing is so powerful.

You don't need to test every possible number.

You test the places where behavior changes.

The edge is where the system's rules become visible.


Zero Is a Surprisingly Powerful Number

Programmers sometimes think about positive quantities first.

Then zero appears.

Zero is interesting because it often represents absence without being the same thing as "nothing happened."

Consider:

average = total / count

What happens when:

count = 0

Or:

const percentage = completed / total * 100;

What happens when:

total = 0;

Or:

items[0]

What happens when the list is empty?

Zero forces us to distinguish between:

nothing exists

and

something exists with a value of zero.

Those are different concepts.

An account balance of zero is not the same thing as an account that doesn't exist.

A cart with zero products is not necessarily an invalid cart.

A search returning zero results is still a successful search.

Thinking carefully about zero can improve an entire system's design.


Empty Is Not the Same as Missing

Another fascinating category of edge cases is the difference between empty and missing.

Consider:

{
  "name": ""
}

versus:

{}

The first says:

A name field exists, but its value is empty.

The second says:

A name field was not provided.

Those states may look similar.

They are not necessarily equivalent.

The same distinction appears everywhere.

null
undefined
""
[]
{}
0
false

Different programming languages handle these values differently.

Different frameworks interpret them differently.

Different databases store them differently.

And different business rules may assign completely different meanings to them.

Good programmers learn not to collapse different states into one simply because they look similar.


The Edge of Time

Time is another place where software becomes interesting.

A developer might write:

if (hour < 12) {
    greeting = "Good morning";
}

Simple.

But time contains boundaries everywhere.

What happens at:

11:59
12:00
23:59
00:00

What happens when a month ends?

What happens when February has fewer days?

What happens when a year changes?

What happens when a subscription expires exactly at midnight?

What happens when a user creates something at:

2026-12-31 23:59:59

and another system processes it at:

2027-01-01 00:00:01

Time is not just a number on a clock.

It is a system boundary.

This is why date and time bugs can feel so strange.

The code isn't necessarily wrong.

The assumptions surrounding time are incomplete.


The Edge of Strings

Text looks simple until humans start using it.

A developer may test:

Derek

But users don't necessarily provide five ordinary ASCII characters.

They might provide:

Derek Mwale

or:

José

or:

李明

or a name containing an apostrophe, hyphen, accent, emoji, or another Unicode character.

Then there are spaces.

What is the difference between:

"Derek"

and:

" Derek "

Should they be treated as the same input?

What about:

""

What about a string containing only spaces?

What about an extremely long string?

Text is not merely characters.

It is data with structure, encoding, length, meaning, and context.

Edge-case thinking encourages us to stop testing only the convenient examples.


The Edge of Lists

Lists are another excellent source of programming lessons.

Suppose your application displays a list of notifications.

You test it with:

10 notifications

Everything looks great.

But the UI may behave very differently with:

0 notifications
1 notification
2 notifications
100 notifications
10,000 notifications

These are not merely different quantities.

They can produce different interface states.

With zero items, you need an empty state.

With one item, singular wording may matter.

With thousands of items, pagination or virtualization may become important.

The list itself becomes a small model of the real world.

Good interfaces don't simply display data.

They represent the different states that data can occupy.


The Double-Click Problem

One of the most interesting edge cases isn't unusual input.

It is unusual timing.

Imagine a user clicks:

Pay Now

The application sends a request.

But the user doesn't see immediate feedback.

So they click again.

Now there are two requests.

If the backend isn't designed for this possibility, the same operation might happen twice.

The developer may have thought:

A user clicks the button once.

The system should instead think:

A request may arrive more than once.

This is a profound shift.

It moves edge-case thinking from the interface into the architecture.

The backend shouldn't blindly trust that clients behave perfectly.

Systems communicate through networks.

Networks retry.

Clients retry.

Users retry.

Browsers refresh.

Mobile connections disappear.

Requests can be duplicated.

Good systems account for these realities.


Failure Is Also a State

Many applications are designed around success.

Loading
Success

But real applications have more states:

Idle
Loading
Success
Empty
Error
Timeout
Unauthorized
Forbidden
Offline
Retrying
Partial

A useful design exercise is to ask:

What states can this operation actually have?

Suppose an API loads a user's profile.

It isn't simply:

Profile exists.

It might be:

Request hasn't started.
Request is loading.
Request succeeded.
Profile doesn't exist.
Request failed.
Authentication expired.
Network unavailable.
Server unavailable.

The application becomes much more robust when these states are explicitly represented.

Edge-case thinking is therefore closely related to state-machine thinking.

You stop imagining software as a sequence of ideal events.

You start imagining it as a collection of possible states and transitions.


Edge Cases Improve API Design

APIs are particularly sensitive to edge cases because they form boundaries between systems.

Imagine an endpoint:

GET /users/123/orders

What should happen if:

User 123 exists and has orders
User 123 exists and has no orders
User 123 doesn't exist
User 123 exists but the requester isn't authorized
Database is unavailable

These situations should not accidentally produce indistinguishable responses.

The API contract should communicate meaningful states.

This is one reason good API design is more than choosing endpoint names.

You are designing a language between systems.

And languages need precise meanings.


The Edge Case You Didn't Know Was an Edge Case

Perhaps the most interesting part of edge-case thinking is that you don't always know what the edge case will be.

You can prepare for:

0
1
maximum
empty
null
duplicate
missing
timeout

But real systems eventually reveal stranger situations.

A user may perform actions in an unexpected order.

A third-party service may return something unusual.

A browser may behave differently.

A database migration may expose an old assumption.

A piece of data created five years ago may still exist.

A legacy record may not conform to today's expectations.

This is why edge-case thinking is not simply a checklist.

It is a mindset.

You are training yourself to notice uncertainty.


The Five-Question Habit

When building a feature, I like to imagine asking five simple questions.

1. What happens when there is nothing?

0
[]
{}
null
empty

2. What happens when there is too much?

huge input
huge list
large file
many requests
large number

3. What happens when something happens twice?

duplicate request
duplicate record
double click
retry
refresh

4. What happens when something arrives late?

slow network
delayed message
expired session
late response

5. What happens when something is missing?

missing field
missing record
missing relationship
missing configuration
missing service

These five questions won't discover every edge case.

But they create a habit of looking beyond the happy path.


Edge Cases and Elegant Code

Interestingly, thinking about edge cases can lead to simpler code.

This might seem strange.

Wouldn't handling more possibilities make code more complicated?

Sometimes it does.

But often, the opposite happens.

Suppose a system explicitly models its states:

Loading
Success(data)
Empty
Error(reason)

Now the rest of the application doesn't have to guess.

Instead of scattered checks everywhere, the system has clear boundaries.

Good abstractions don't hide complexity by pretending it doesn't exist.

They organize complexity.

That is one of the beautiful things about software architecture.

A complicated reality can sometimes be transformed into a small number of well-defined states.


Edge Cases Are Design Clues

When you discover an edge case, don't immediately think:

"How do I patch this?"

Instead ask:

"What does this reveal about my design?"

Suppose an empty shopping cart causes five different components to crash.

You could patch all five components.

Or you could recognize that the system never properly modeled the empty-cart state.

The second solution is more interesting.

A bug can be a clue.

An edge case can reveal a missing abstraction.

A failing test can expose an undocumented assumption.

An unexpected input can reveal an incomplete model of reality.

This is why experienced programmers often seem unusually interested in strange behavior.

They aren't fascinated by bugs for their own sake.

They are looking for what the bug is trying to tell them.


Thinking Like the Data

One useful technique is to stop thinking only like the developer.

Think like the data.

Imagine a database record moving through the system.

What states can it occupy?

Created
Updated
Duplicated
Archived
Deleted
Missing
Partially populated
Legacy

Now imagine a request.

Created
Delayed
Retried
Duplicated
Rejected
Processed
Timed out

Now imagine a user.

New
Inactive
Active
Returning
Anonymous
Partially onboarded

The system becomes easier to reason about when you think in states rather than isolated functions.

You begin asking:

What can exist here?

What can change?

What can disappear?

What can happen twice?

What can happen out of order?

Those questions are powerful.


The Programmer's Peripheral Vision

There is a kind of programming intuition that develops slowly.

You read a function and immediately notice:

"What if this list is empty?"

You see:

result[0]

and your mind automatically asks:

"What if there is no result?"

You see:

await save()

and wonder:

"What happens if this runs twice?"

You see:

start_date
end_date

and ask:

"What if they are equal?"

This is almost like peripheral vision.

You are not staring directly at the edge case.

You simply become accustomed to noticing where it might exist.

That habit is valuable because software is full of boundaries.


Testing the Edges

Testing becomes much more interesting when you deliberately move toward boundaries.

Instead of testing only:

username = "Derek"
age = 25
items = 5

you might test:

username = ""
username = " "
username = very long string

age = 0
age = minimum valid age
age = maximum valid age
age = negative value

items = 0
items = 1
items = maximum
items = maximum + 1

You are not trying to create bizarre inputs for entertainment.

You are testing the shape of the system.

A good test suite doesn't merely ask:

Does the normal case work?

It also asks:

Where does behavior change?

That is where the interesting tests live.


Edge Cases Make Software More Human

There is an unexpected connection between edge cases and empathy.

A programmer often builds software from the perspective of the person who understands the system.

But users don't necessarily understand the system.

They make mistakes.

They change their minds.

They click buttons twice.

They leave forms unfinished.

They return months later.

They use unexpected data.

They lose their connection.

They forget passwords.

They refresh pages.

They use old devices.

They interact with software in ways the original developer never imagined.

Thinking about edge cases is therefore partly about imagining another person's experience.

Not just:

"What should happen?"

But:

"What might someone actually do?"

That question creates better software.


The Edge Is Where Reality Begins

The happy path is a useful abstraction.

It gives us a clean starting point.

But reality is rarely clean.

Real systems contain:

empty values
duplicate actions
delays
failures
unexpected inputs
boundary numbers
missing records
old data
new data
partial states

These aren't annoyances surrounding the "real" application.

They are part of the application.

A login system isn't only the successful login.

A payment system isn't only the successful payment.

A search engine isn't only the search that returns results.

A database isn't only the query that finds a record.

A user interface isn't only the screen with perfect data.

The edges belong to the system too.

And once you start seeing them, your approach to programming changes.


Building the Habit

You don't need to memorize thousands of edge cases.

You need to develop the habit of looking for them.

When you write a function, ask:

What if the input is empty?

When you build an API, ask:

What if the request arrives twice?

When you design a database, ask:

What if the relationship doesn't exist?

When you build a UI, ask:

What does this screen look like with no data?

When you handle numbers, ask:

What happens at the boundary?

When you work with time, ask:

What happens when the date changes?

When you work with external services, ask:

What happens when they don't respond?

When you process user input, ask:

What happens when reality doesn't match my example?

These questions become second nature eventually.

And that is the goal.

Not to become paranoid about software.

Not to imagine every impossible scenario.

But to become curious about the assumptions hiding inside your code.


The Quiet Power of Edge-Case Thinking

Programming is often described as the art of giving computers precise instructions.

But there is another side to it.

Programming is also the art of anticipating reality.

The computer will execute exactly what we tell it.

Reality, however, will keep producing situations we didn't explicitly imagine.

That is why edge-case thinking matters.

It teaches us to look beyond the obvious.

Beyond:

1

and consider:

0
2
maximum
maximum + 1

Beyond:

success

and consider:

empty
missing
delayed
duplicated
failed

Beyond:

one request

and consider:

two requests

Beyond:

today

and consider:

tomorrow
next month
next year

The deeper lesson is simple:

Good software doesn't only understand what should happen. It understands what could happen.

And the more you practice looking toward the edges, the better you become at seeing the shape of the whole system.

Eventually, you start noticing something beautiful.

The edge cases aren't really edges.

They are clues.

They reveal assumptions.

They expose hidden states.

They illuminate boundaries.

They tell us where our abstractions meet reality.

And perhaps that is one of the quiet skills of programming:

learning to look where everyone else stopped looking.

Because sometimes the most important line of code is not the one that handles the normal case.

It is the one that answers a question nobody thought to ask.

Software in My Mind. Rock in My Soul.

2 Comments

2 votes
1
🔥 Join developers growing publicly
Share your knowledge, build in public, and grow your developer presence with a global community.

More Posts

TypeScript Complexity Has Finally Reached the Point of Total Absurdity

Karol Modelski - Apr 23

How AI Is Changing Web Development, and What Developers Still Need to Understand

Daniel Decker - Nov 10

A Message From Our Founder: On the Winding Down of LaaSy™

Ken W. Algerverified - Oct 29

Systems Thinking: Thriving in the Third Golden Age of Software

Tom Smithverified - Apr 15

Merancang Backend Bisnis ISP: API Pelanggan, Paket Internet, Invoice, dan Tiket Support

Masbadar - Mar 13
chevron_left
2.4k Points • 112 Badges
Kapiri Mposhi, Zambia. • zambianmillenial.com
52Posts
10Comments
376Connections
Derek Mwale — Where Code Meets Creativity.

Commenters (This Week)

3 comments
1 comment
1 comment

Contribute meaningful comments to climb the leaderboard and earn badges!