A Catalogue of Failure

The first version of this essay failed too.

That is probably the right place to begin.

I asked for my failure story and got something clean enough to sound as if failure had already become wisdom. It had sections. It had conclusions. It even knew what every wound was supposed to mean.

I read it and knew something was missing.

Me.

Not my résumé. Not a list of bad outcomes. Not the polished narrator who has already climbed out of everything and can now explain the architecture of the hole.

Me — the person who is still inside several of these things.

So I am rewriting it before the first version becomes another lie I keep because it looks professional.

I do not want a motivational essay.

I do not want to pretend every rejection made me stronger.

Some of them made me angry.

Some embarrassed me.

Some were my fault.

Some were not.

Some were unfinished work that I called failure because I was impatient.

Some were systems failing around me and then leaving me to carry the result as though it described my character.

Some were people choosing differently from what I wanted.

Some were simply mathematics.

79.50 is less than 80.

There is no philosophy capable of negotiating with that.

And some things are still unresolved, which means calling them failures now would only be another way of dramatizing uncertainty.

That distinction matters to me more than the word itself.

Not everything that hurt was my failure

This is the part I missed the first time.

I have a habit of taking every bad outcome and collapsing it into one sentence:

I failed again.

It is efficient.

It is also bad reasoning.

If an institution withholds something I completed, that is not identical to me refusing to complete it.

If a bug report has no impact, that is a research failure.

If I misunderstand a protocol response, that is my technical mistake.

If a project is locally working but not verified in the real environment, that is unfinished engineering.

If an application has not answered me yet, it is not a rejection just because silence hurts.

If a relationship ends, the ending is real without one person having to be declared the defective component.

If my workplace gives me a system failure and still expects an outcome, the pressure is real even if the software error was not mine.

I need a vocabulary larger than failure.

But I also do not want vocabulary to become escape.

There are things here that were absolutely mine.

The degree that did not become the life I thought I was entering

I entered B.Sc. Anesthesia Technology in the 2018/2019 period thinking the path at least had a shape.

Study.

Clinical training.

Internship.

Degree.

Work.

Maybe a master’s later.

The shape broke.

After a college transfer, the internship path became a mess. I completed the theoretical years, but roughly nine months of the internship period I expected to count did not turn into the clean completion I had planned around.

Years that were supposed to close stayed psychologically open.

That matters because when people look at a timeline later, they see a gap.

A gap looks passive.

Living inside it was not passive.

There were institutions, transfer rules, closed possibilities, uncertainty over placement, and the slow recognition that wanting a pathway to remain valid does not keep it valid.

I can also admit my part: I did not respond to that disruption by becoming singularly focused.

I scattered.

I learned other things.

I kept imagining different lives.

Computing entered.

Cybersecurity entered.

AI entered.

Philosophy entered.

Neuroscience kept calling me back.

What looked from outside like intellectual range also became a way of refusing to choose one identity long enough to let it become boring.

Eventually I completed a BCA in 2026.

That is not a failure.

But completing it did not magically erase the earlier years or convert a nonlinear path into the kind of three-line career story recruiters like.

I still had to explain why someone trained around operating theatres ended up writing Python, running Linux, building AI systems, reading security reports, thinking about cognition, and working a postal job in between.

I still have to explain it.

The job that pays me and the life I keep trying to build beside it

I work in the postal system.

That sentence is not an apology.

My job has paid me while several of my imagined careers paid me nothing.

It has also become one of the places where I feel the contradiction of my life most clearly.

I can finish duty and think about RAG pipelines.

I can handle postal records and later debug Docker.

I can be asked for business numbers and then spend the night reading a protocol specification.

I can complain about a target structure in the morning and build software intended to analyse institutional pressure in the evening.

That sounds almost cinematic when written like that.

It is less cinematic when I am tired.

I have made mistakes at work too.

Records I should have closed sooner.

Physical paperwork that sat longer than it should have.

Processes I understood late.

Backlogs that became heavier because they were postponed.

I do not need to name an office, a date, or a person to admit that.

There is a version of me who wants every failure to have an external cause because external causes preserve self-respect.

That version is dishonest.

At the same time, there have been periods when business targets, campaign days, after-hours messages, system failures, leave anxiety, and threats of consequences made the job feel less like stable employment and more like something I had to defend myself inside.

I eventually filed grievances.

Those grievances did not create a movie ending either.

Escalation becomes forwarding.

Forwarding becomes fact-finding.

The structure continues.

I continue.

This is one of the strangest failures to write about because I do not think the job itself is a failure.

I think my inability to make peace with the distance between the job I have and the work I want is one of the central tensions of my twenties.

Half a percentage point is still a wall

I once got 79.50% on a graded neural-imaging assignment.

The pass threshold was 80%.

Half a percentage point.

There are failures that require interpretation.

This one barely does.

I was interested in the subject.

I cared.

I was close.

I failed the threshold.

All four statements can coexist.

That tiny number stayed with me because it exposed one of my worst instincts: I want effort, intelligence, interest, and outcome to obey each other.

They do not.

A system can acknowledge none of the first three and still record the fourth.

79.50. Fail.

The database is not insulting me.

It is applying a rule.

I was simply on the wrong side of it.

Seventeen reports can still equal zero

Bug bounty work gave me the least romantic education in effort.

I wanted security research to reward obsession.

I tried to use AI as leverage and sometimes used it as anesthesia

This part is harder to admit because AI genuinely changed what I can build.

I am not pretending the tools are useless.

They are not.

A model can read a codebase faster than I can.

It can generate tests, compare protocol states, suggest attack surfaces, explain unfamiliar libraries, draft a report, challenge assumptions, and help me move between fields that would otherwise take me much longer to enter.

But there were periods when I treated the next model as if it would finally remove the human part of the work.

The next free router.

The next reasoning tier.

The next Claude mode.

The next DeepSeek release.

The next Qwen.

The next agent.

The next API key.

The next prompt that would stop classifiers from misunderstanding legitimate research.

The next orchestration layer.

I could always move the hope one abstraction higher.

Then the API expired.

Credits disappeared.

A payment failed.

A CLI broke.

Disk space vanished.

Docker filled the machine.

A model refused.

Another model confidently produced something that looked excellent and failed against the real environment.

An automation platform suspended one of my security workflows after wording I used made the authorization look less defensible than it actually was. I had to acknowledge that my phrasing was bad and return to strict, recognizable scope.

That was not censorship ruining my genius.

That was me learning that authorization has to be legible, not merely present in my head.

There is a reason my brother’s manual way of looking at cybersecurity keeps surviving every new model I bring into the room.

Manual work is slow.

It is also where the excuses disappear.

He can ask: did it actually happen?

I can ask a model: what else should we test?

The useful system is not human versus AI.

It is human skepticism plus machine acceleration.

I wanted the machine to make rejection less likely.

Instead, it made it possible to produce weak ideas faster too.

I kept building exits

When one path frightened me, I created another repository.

MORPHIA.

IFA — Info For All.

PostalMind.

Luneon.

SourceLens.

ShiftPilot.

Regard.

Security labs.

Agents.

Dashboards.

Mining experiments.

Local-model setups.

Education ideas.

WhatsApp assistants.

News systems.

Publishing systems.

Sometimes the naming came before the product had earned a name.

That is one of my patterns.

A new project has no disappointment attached to it yet.

No failed deployment.

No reviewer.

No unpaid invoice.

No user saying, “I don’t need this.”

No backlog.

No technical debt.

No proof that the idea is smaller than the fantasy.

Beginning feels pure.

Maintenance does not.

I became good at beginnings.

That is not the same as becoming good at finishing.

MORPHIA is a good example.

The local architecture became real: FastAPI, Postgres, Redis, React, tool adapters, evidence structures, tests.

And still, release confidence kept depending on things that could not be wished away:

runtime container inspection.

secret inspection.

real browser and mobile verification.

a credentialed live model call.

service-backed CI.

evidence retrieval that works outside mocks.

quota behavior.

the difference between a green local test and a trustworthy deployed system.

At one point I wanted MORPHIA to become “10000× better” than a competing SOC idea.

The sentence was ambition.

The remaining verification gates were reality.

Regard followed the same pattern.

Editorial integration.

Testnet Editions.

Image handling.

Wallet flows.

Quota and persistence.

Authenticated controllers.

Receipt reconciliation.

A beautiful idea is still unfinished if the boring gates are unfinished.

PostalMind had its own version: deterministic demo behavior, deployment settings, missing-key behavior, mobile checks, evidence safety.

I can point to working code in all of these places.

I can also point to unfinished truth.

Both are mine.

The internship where 341 tests did not buy the result

In 2026 I joined an AI internship built around a fast sequence of projects.

One week.

Then another.

Productivity assistant.

RAG work.

Automation.

Capstone.

Build.

Post.

Move.

At one point one of my builds had 341 tests across 27 files.

That number made me feel serious.

Then the stipend winners were announced.

Three other people.

Not me.

The performance stipend was ₹10,000.

I received the certificate.

I did not receive the result I wanted.

The certificate became almost offensive for a few minutes because participation was not the thing I had been measuring myself against.

I asked the question exactly as it arrived in my head:

Where did I fuck up?

Not: “What valuable learning can I extract from this journey?”

Where did I fuck up?

Maybe I overbuilt.

Maybe I made the evaluator work too hard to understand the value.

Maybe I confused tests with product clarity.

Maybe the selected projects were simply better.

Maybe presentation mattered more than I wanted it to.

Maybe I treated engineering effort as if effort itself were a feature.

I still do not have perfect access to the evaluator’s decision function.

What I do have is the outcome.

I was not selected.

That is enough to study without inventing a conspiracy or a comforting explanation.

Applications are cruel because silence has no shape

I applied for AI roles.

WordPress internships.

Entry-level web work.

Vibe-coding roles.

Technical operations.

Remote opportunities.

Some applications were weak fits.

Some were better fits.

Some I probably undersold because my résumé made independent projects look smaller than the work they contained.

Some are still pending.

And this is where I need to stop abusing the word failure.

A pending application is not a rejection.

A company that never answers may function emotionally like rejection, but the factual claim is smaller:

I did not get an answer.

That distinction sounds pedantic until you notice how often I convert uncertainty into self-judgment.

Silence becomes “I wasn’t good enough.”

A delay becomes “I failed again.”

An eligibility mismatch becomes “BCA is useless.”

A role preferring engineering degrees becomes a global conclusion about my future.

That is not analysis.

That is pain trying to become statistics.

Money has never cared about my potential

Money is the least philosophical participant in this story.

A GPU does not care that I understand distributed systems.

An API bill does not care that I am learning.

A subscription does not become cheaper because the project is meaningful.

There were periods when my total available cash was smaller than the tooling stack I wanted to maintain.

I paid for platforms.

I accumulated bills.

I tried free tiers.

I chased credits.

I compared models by cost because cost was not an abstract optimization problem for me.

Sometimes the difference between “best model” and “usable model” was simply whether I could afford another month.

I also experimented with mining.

I had an RTX 4070.

On paper that sounds like capacity.

In practice I sometimes found myself staring at balances small enough to be comic.

One tracked balance was ₹57.47.

At another point I watched the mining/crypto bag move down by several percent while I kept recalculating whether the setup could ever become meaningful monthly income.

A machine can be powerful and still have bad economics.

That sentence applies to more than GPUs.

I have imagined workstations costing lakhs while earning a salary that made those builds closer to architecture drawings than purchase plans.

I wanted 256 GB ECC RAM and professional GPUs while also asking whether I could create a one-year buffer to leave my current job.

Ambition can be technically coherent and financially absurd at the same time.

I know because I keep producing examples.

Some failures were actually constraints wearing my face

This is where I have to be careful.

There is a seductive form of self-criticism where a person takes responsibility for everything because it feels morally cleaner than admitting dependence.

If everything is my fault, then everything is theoretically under my control.

That can feel powerful.

It is also false.

The internship disruption was not entirely mine.

Degree eligibility filters are not entirely mine.

A platform changing its free tier is not mine.

An API provider expiring access is not mine.

A mining market dropping is not mine.

A postal application failing during a work campaign is not mine.

A bounty program changing rules is not mine.

A reviewer making a different judgment is not mine.

Someone deciding not to share a future with me is not mine.

What is mine is what I do around those facts.

Sometimes I did that well.

Sometimes I did not.

Sometimes I wasted days fighting the existence of the constraint instead of deciding what to do next.

That is probably one of my actual failures.

Love is the failure I cannot turn into a bug report

Technical failure gives me logs.

Love gives me memory.

That is worse.

There was a person I imagined inside my future.

The future did not happen.

I can analyse attachment.

I can discuss consent, monogamy, truth, family, closure, autonomy, memory, projection, and the ethics of letting another person remain unknowable.

None of that changes the simple fact that absence has a body.

Sometimes my language stops behaving properly around it.

I wrote this recently and resisted correcting it because the fracture was part of what I meant:

To more I dwell onto love
The more memories it floods me apart
Eventhough in the gray of sadness
I feel to ponder a thought
A thought of her , that’s never felt apart

That is not formal English.

I know.

But “floods me apart” says something that “overwhelms me” does not.

The memory arrives and fills me while also separating me from whatever version of the present does not contain her.

I also wrote:

To ponder is to prove
To love is to linger
To carry is to be cautious
Yet here I am dwelling in the sadness of her absence

I am not putting those lines here to make the relationship sound grander than it was.

I am putting them here because failure does not always appear in my life as a result screen.

Sometimes it appears as grammar losing control.

The relationship ended.

That does not mean the love was fake.

The love remaining does not mean the relationship should return.

Those are different propositions.

It took me too long to stop using one as evidence for the other.

I still fail at that distinction some days.

I even failed at publishing the essay about failure

There is something almost embarrassingly appropriate about what happened with this piece.

I asked for my failure story.

The first version went into Regard.

I read it.

It was too clean.

Then I wanted the public link immediately.

The intended Regard deployment was not actually verified live.

A fallback publishing route failed because the hosting account would not permit the deployment.

So the essay about failure acquired a failed deployment before it had been alive for an hour.

I ended up putting an emergency public copy on an existing GitHub Pages surface while keeping the canonical article in Regard.

And then I came back and said the writing itself was wrong.

That is this revision.

I like that more than I should.

Not because failure is cute.

Because it demonstrates the exact thing I am trying to say:

done is not the same as true.

The first version was done.

This version is closer to true.

Progress and failure are allowed to coexist

One reason I become irrational about failure is that I treat progress as if it should cancel it.

It does not.

I completed the BCA.

I have built real software.

I have learned enough Linux to maintain machines that also make me swear at disk usage.

I have learned enough security to know when an exciting hypothesis is probably nothing.

I have improved at coding.

During one hundred-days coding work, I watched my rank move from roughly the high hundreds toward the low hundreds.

That did not make the rejected reports disappear.

The internship certificate did not become the stipend.

The projects did not automatically become companies.

The relationship did not return because I became more reflective.

Progress is not a refund.

It is just another line in the same record.

That is more difficult for me to accept than simple failure because it removes the fantasy that one future victory will retroactively settle the account.

Nothing is going to come back and convert every old “no” into a delayed “yes.”

Some things remain no.

Some things remain unfinished.

Some become irrelevant.

Some become foundations.

I do not know which category every current struggle will enter.

My real failure pattern is not falling; it is trying to turn every fall into identity

When something goes wrong, I become total.

Not this report failed.

I am bad at bug bounty.

Not this application went nowhere.

Nobody will hire me.

Not this deployment broke.

I cannot finish anything.

Not this relationship ended.

I will not be understood like that again.

Not this job exhausts me.

I wasted my twenties.

Not this model burned credits.

I chose the wrong tool again.

That transformation from event to identity happens almost automatically.

It also explains why I keep starting new systems.

A new project gives me a temporary identity with no negative evidence.

Founder.

Researcher.

Developer.

Security analyst.

Writer.

AI engineer.

Philosopher.

Builder.

Then reality arrives and narrows the fantasy.

The healthier answer is not to choose one flattering identity and protect it.

It is to become specific.

This report failed because the impact was not demonstrated.

This deployment failed because the environment was not actually configured.

This application was ineligible because of the degree requirement.

This project is unfinished because the browser verification is still missing.

This relationship ended because the shared relationship was no longer being sustained, whatever private reasons existed behind that.

Specificity hurts less dramatically.

It also gives me somewhere to work.

The cemetery stays

I used to want my portfolio to hide the dead things.

Now I think the cemetery belongs in it.

The abandoned repo.

The branch that taught me one thing and never merged.

The agent that produced beautiful nonsense.

The prompt that burned credits.

The free model that stopped being free.

The API key that expired.

The bug that was not a bug.

The PoC that did not establish impact.

The security workflow that got suspended until I made the scope legible.

The 341 tests that did not win the stipend.

The certificate that did not become a job.

The application with no reply.

The mining calculation that proved the monthly income was not worth fantasizing about.

The hardware build that existed more vividly in a spreadsheet than in my room.

The degree path that took a different shape.

The work grievance that did not dissolve the structure around me.

The relationship that became memory.

The first version of this essay.

Keep them.

Not as trophies.

Evidence.

I do not want redemption yet

This is where a conventional essay is supposed to rise.

The music changes.

The failures become stepping stones.

The narrator tells you he would not change anything because every wound made him who he is.

I do not believe that.

There are things I would change.

There are reports I wish I had reasoned through better before submitting.

There is money I wish I had not spent.

There are projects I wish I had finished before naming the next one.

There are hours I wish I had slept instead of asking another model the same question in a more expensive way.

There are academic paths I wish had been cleaner.

There are work mistakes I wish I had not made.

There are conversations I would handle differently.

There is a future with someone that I wanted and did not get.

I do not need to thank failure for any of that.

Gratitude is not required for learning.

What I can do is refuse to falsify the record.

I have failed.

Systems have failed around me.

People have rejected my work.

Some of my work deserved rejection.

Some things I called failures were only delays.

Some things I called personal weakness were material constraints.

Some ambitions were ridiculous relative to the resources I had.

Some ambitions are still worth keeping.

Some love remained after the relationship stopped.

Some projects remained after the excitement stopped.

And I am still here, which is not a victory statement.

It is merely the current state.

I am still working a job while trying to build another professional life.

Still trying to become credible enough in security that evidence survives triage.

Still trying to finish MORPHIA instead of only imagining what it could become.

Still trying to make Regard worthy of the things I put inside it.

Still applying.

Still studying.

Still writing.

Still capable of getting the next thing wrong.

The first version ended with a line I still believe:

Tomorrow adds another row.

But I want to add something now.

A dataset does not become honest because it contains more rows.

It becomes honest when I stop editing every row to protect the story I want it to tell.

So this is the row as it is.

Not redeemed.

Not defeated.

Recorded.