How Memset Helped Me Become a Senior Engineer

The questions that have decided my job interviews were almost never about what I had been working on that week. They reached back. How a particular concurrency model behaves under real load, why one memory decision matters on a constrained device, a networking detail that only bites you in production. The interviewer was not checking whether I could learn something new. They were checking what had stayed.

That distinction took me years to understand. Early on I assumed senior engineers were simply faster thinkers, that seniority was raw horsepower. After ten years in mobile development, six of them on an app that pairs with continuous glucose monitors where I eventually led the mobile team, I think the real difference is duller and more useful than that. A senior engineer is mostly someone who still remembers.

So I will make a claim that sounds immodest and is meant seriously: I do not believe I would have become a senior software engineer without a deliberate system for remembering. Not a better memory, a system. This profession asks you to hold an enormous and constantly growing pile of terms, patterns, and hard-won failures in your head, then recall the right one at the right moment, often with someone watching. Talent gets you in the door. Retention is what compounds once you are inside.

The system I settled on is spaced repetition, run with a strict daily cap, and I eventually shaped it into the app I now build, Memset. My own career is the closest thing I have to proof that it works.

Seniority is a memory problem

Software has a vocabulary problem nobody warns you about. Every layer you touch arrives with its own dense dictionary. Languages have semantics and sharp edges. Frameworks ship APIs that shift every release. Systems carry protocols, consistency models, and a long catalogue of ways to fail. A junior engineer can get by looking each thing up on demand. A senior engineer is expected to already hold most of it, to notice how today’s problem rhymes with one from three years ago, and to do it in the time it takes to sketch on a whiteboard.

The trap is that reading something once feels like learning it. You follow a clean explanation of how a database handles isolation levels, you nod, you close the tab sure that you know it. That feeling is the illusion of fluency, and it is expensive. A week later the details have gone soft. A month later they are gone, and you would not bet you ever read them.

Human memory simply works this way. Hermann Ebbinghaus measured it in the 1880s with what we now call the forgetting curve: without reinforcement, new material falls away quickly, and most of it is gone within days. The decline is steep and it is the default setting. Whatever you understood this morning is already leaking unless something interrupts the curve.

What an interview is really testing

Interviews are where this stopped being theoretical for me. A senior interview compresses years of claimed experience into about an hour, and the questions that carry the most weight rarely concern yesterday’s ticket. Explain how this protocol recovers from failure. Walk me through the tradeoffs between these two architectures. Why does this code behave differently on a slow network. The candidates who do well are not the ones who studied the night before. You cannot cram a decade.

Seniority is the quiet accumulation of everything you refused to forget.

Across a lot of these conversations I noticed that my real advantage was retention, not speed. I was not out-thinking the other people in the room. I had simply kept more of what I had read and built, and kept it in a form I could pull up on demand. A concept I had reviewed on a schedule months earlier would surface mid-sentence, intact, while a fact I had read exactly once stayed just out of reach. Remembering is the job, far more than interview prep usually admits.

The habit that made it stick

None of this runs on willpower, and it definitely does not run on re-reading. Re-reading is comfortable and close to useless. It builds a warm sense of familiarity, not the ability to retrieve. What actually moves material into long-term memory is pulling it back out, repeatedly, at growing intervals, right as you are about to lose it. Researchers call the first half the testing effect and the second half spaced repetition, and together they are among the most durable findings in the science of learning.

Classic spaced repetition tools have one cruel flaw: they punish you for learning a lot. Add enough material and the daily queue swells into a second job, so people quit. Abandonment, not difficulty, is what actually kills a review habit. I hit that wall with my own studying, which is why I built my version around a hard daily cap. I decide how many reviews I am willing to do on an ordinary working day, and the planner never exceeds it. Overflow waits its turn. A missed day does not erase the streak. The goal was to make the habit boring and survivable instead of heroic and abandoned.

In Memset the unit is deliberately small. A memset is just a lightweight reference to something I am learning, a pointer carrying a title, a short summary, a Strategy that decides how it repeats, and a Category to group it. It does not store the material. The conference talk, the documentation page, the book chapter, the codebase all stay where they already live. The app owns only the timing, the part my brain is worst at. That separation is what lets me keep a year of accumulated engineering knowledge under review without first rebuilding it into flashcards I would never finish making.

From glucose monitors to modern AI

Let me ground this, because “a habit built my career” is easy to assert and fair to doubt.

For six years I worked on an app that pairs with continuous glucose monitors, software people with diabetes lean on to make real decisions about their health. That domain does not forgive much. You carry medical concepts, device protocols, regulatory constraints, and the precise failure modes of your own system, and you carry them for years, because the bug in front of you today might turn on a detail someone wrote down eighteen months ago. The engineers who could hold that context were the ones who moved fast without breaking things that mattered. By the time I was leading the mobile team, what I was really leading with was retained context, mine and the team’s.

I did not show up with that memory. I maintained it. The concepts I reviewed on a schedule stayed sharp enough to use in a design discussion with no tab open. The ones I let drift, I re-learned the slow way, usually at the worst possible moment.

The same mechanism is carrying me through a far faster subject now. I am learning modern AI, a field that rewrites its own vocabulary every few months, and the only reason any of it sticks is that I run it through the same review loop. The same loop, years earlier, is how I learned English well enough to work and write in it, which is its own long-term retention test. Different material, identical method.

What I would tell an engineer who wants to level up

If you are trying to grow into senior work, the change that matters most is unglamorous: stop measuring learning by what you read, and start measuring it by what you can still recall three months later. That one shift rearranges your habits. You read a little less and review a lot more. You treat a concept as learned only when it survives a delay, not when it merely makes sense while the explanation sits in front of you.

A few rules that held up for me:

• Review beats re-reading. Close the doc and try to rebuild the idea from memory before you let yourself open it again.
• Keep the daily load small enough that a brutal week cannot break it. A sustainable ten minutes beats an ambitious hour you quietly drop.
• Trust the schedule over your gut. The moment a concept feels slightly stale is usually the moment reviewing it pays the most.

None of this requires an unusual memory. Mine is ordinary. It requires refusing to let a decade of hard-won knowledge drain quietly back down the forgetting curve while you are busy earning more of it. Seniority, in my experience, is the visible output of an invisible habit: showing up to review, in small amounts, for years.

My career is the evidence I trust most. The interviews that went my way, the systems I could hold whole in my head, the team I was eventually trusted to lead, all of it sits on information I made deliberate choices to keep. The work made me an engineer. Remembering the work made me a senior one.

If you want a review planner built around holding knowledge for the long haul, without it swelling into a second job, that is exactly what Memset is for.