The :q!

Details in this chapter have been changed, combined, and generalized to protect others’ privacy. This is not a description of any specific individual or company.

I spent 7 years on a team that I got really comfortable with. My teammates and I worked very well together. We had the same values around the craft, how things should be built, and that honest code reviews and nitpick comments were fine. However, after 7 years, I felt that I needed a challenge. I was getting bored of my work. I felt like I was solving the same problems again and again.

For a long time, I had been good at my job in a way that felt dependable and quiet. I could walk into almost any problem and feel my brain click into place. I knew who to ask. I knew which questions to ask. I knew the invisible map of what mattered, what didn’t, what was urgent, what could wait.

A former teammate I trusted mentioned an opening on his team over lunch one Friday. It wasn’t pitched as a life-changing move. It was mentioned casually, like a fact about the weather. I nodded, pretended it didn’t matter, and kept eating. Later that night, it came back to me and I knew it was something I had to try.

The next week, I asked him what the work was like on that team and about his general experience. I asked if I was being naive moving into a field I really didn’t know much about with only application development experience. The answer he gave was honest: it would be different enough to feel like a different career for a while. That should have scared me more than it did but I was still living in the comforts and confidence of my current team.

I was seeking to expand my horizons. At the time, I felt like I could do anything when I’m armed with my debugger and IDE. I wanted to take what I’ve learned over all my experience at the company and see how far it can travel in other areas of software engineering. I had spent a long time at the company already. I knew that making this move would probably be my last move before finding somewhere else to work. I knew it was time to take a chance. I did not want to stay in one spot forever and just be treading water. I wanted to swim in the deeper oceans with the sharks.

The New Team

I remember the first morning on the new team, sitting down at my desk and trying to act like I belonged there. I didn’t just want to belong in the obvious way. I wanted to belong in the subtle way: to know the pace of conversation, the unspoken priorities, the shared jokes, the invisible rules about who can ask what, and when.

Most days, people spoke a different language around me unless we were in an official meeting. I would hear conversations happening around me and not understand why they didn’t just speak English so I could follow too. Meetings became the only place I could reliably follow what was happening. Even then I felt like I was catching the plot mid-season. After meetings, I would return to my desk thinking maybe this time I had enough context to start. Sometimes someone would come over and ask me a couple of questions, and for a moment I would feel the conversation opening. Then they would turn to someone else and continue speaking in a language I didn’t understand. I would go back to staring at my screen, trying to guess what I was missing and what they were talking about.

No one was openly unkind. It was probably just the language they naturally fell into with each other. But the effect was that I felt stranded inside my own workday. I sat at my desk trying to figure things out the whole day, trying to catch someone in between meetings to ask questions. But overall, there was no team to lean on like I was used to. No relationships. No nothing. Everyday felt like I was just banging my head against a wall.

In the beginning, I told myself the discomfort was temporary. Everyone feels lost at first. Everyone feels behind. This is what growth feels like. What I missed was that my confidence had never been purely individual. It was built out of shared context, trust, and the ability to ask a half-formed question and still get help. I was starting to realize how much my old relationships mattered.

My first project was a migration to a new schema format. On paper, it sounded clean: convert one kind of definition into another kind of definition. Standardize. Reduce drift. Make the future easier.

In practice, it was a project built out of hidden context. There were over 2000 services to account for, each with its own decisions baked into its schema. The possibilities were endless, and it felt nearly impossible to come up with all the right combinations.

I spent days reading documentation and internal notes. I understood the words. I could summarize the goal. I could repeat the steps back to myself, but I couldn’t see the path through the work. Every time I tried to start, I felt myself reaching for a question I didn’t yet know how to phrase.

I opened Slack and stared at the names of people I vaguely recognized. I hovered over one familiar contact who I’ve known for years and thought about asking a question, but my pride got in the way. I didn’t want to be that person who transfers and immediately drags their old team member into their new problems. I didn’t want to use anyone as a crutch. I told myself it was pride (and it was). I told myself it was professionalism. I told myself I would figure it out and that I was good enough to be on that team, without any help.

Days turned into weeks. The work moved, but it didn’t move forward. It was often one step forward and two steps back. I was climbing up a muddy hill and my feet couldn’t get a group.

I slept poorly. I woke up already tired. I would open my laptop and feel a wave of resistance like my hands didn’t want to touch the keyboard. The dread wasn’t reserved for Sundays anymore. It became background noise. The sad part was that I used to love my job. I used to be excited every Monday to talk to my team, solve problems, and tackle bugs. However, it became something awful. I looked forward to Fridays when I could try to put the week behind me but after Saturday came, I was dreading what Monday would be like.

I tried to set up time with people to get oriented. Sometimes it happened. Often it didn’t. Not because anyone was cruel, but because everyone was busy, and “getting someone unstuck” is the kind of work that never feels urgent until you’re the person stuck.

At one point I built a working prototype using recursion and iterating through the many various types that were possible to encounter in a schema. Of course, the problem was that there was no way to know of all the possibilities and every little decision that was baked into each service. Instead, it handled a narrow sample input and produced the sample output it was supposed to produce. But for a moment, I felt something close to relief. I let myself believe I had finally found the pattern and it was just a matter of discovering the possibilities.

Then we tried to run all the other schemas through and it failed miserably.

The failures didn’t just exist in logs. They showed up in the places where progress was tracked, discussed, and judged.

It wasn’t framed as “this is normal when you scale a prototype.” It was framed as evidence. Evidence that I wasn’t moving fast enough, evidence that I wasn’t seeing the obvious patterns, evidence that I was the problem. But was it that?

I learned something that seems obvious in hindsight: the real work wasn’t converting a schema. The real work was discovering all the ways people had already deviated from whatever “standard” was supposed to mean. There were too many systems. Too many variations. Too many edge cases that were only obvious if you already knew where the bodies were buried.

I was told to move faster. I was told it was overdue. I was told the migration needed to happen. I was told to look harder, search more code, find the patterns.

I did. I searched. I made lists. I categorized failures. I tried to build a systematic approach. Each time I thought I had handled a class of cases, another class appeared that made my solution look wrong.

I started working longer hours out of desperation. I kept trying new possibilities, writing new test cases, duplicating schemas so I can ensure my progress wasn’t causing regressions. I wanted to prove to myself that I was making forward progress in the form of passing tests and green check marks. However, trying to cover the possibilities over 2000 services was futile. I wasn’t ever going to get through it in the timeline leadership wanted me to.

There were days when I pushed as hard as I could against blockers and ambiguity and ended up in tears during my late night frustrations.

One night, I turned to my husband and asked, “Can I just quit my job?”

He told me to give it more time. I hadn’t been new in a long time. I spent several years on my old team. Maybe I just needed a little runway. I wanted to believe him because the alternative was terrifying.

Over time, he saw what I was actually living inside. We stopped talking like this was a temporary rough patch and started talking like we needed a plan.

Around then, I started a side project. I knew something had to change. I was becoming depressed every day. I was beginning to lose interest in things I enjoyed the most. I questioned myself and lost my confidence for a long time. And so, I sat at my computer one night, half looking for a new job, half looking for a distraction. In those moments, I started to toy around with making my upcoming interview process easier. I was going to build a tool to help me diagram system design questions easier.

I wanted something easy. Something that is meant for the job. No more Google Drawings or Excalidraw. I started simple, playing around with HTML canvas, exploring how to draw shapes and lines.

Thirty minutes on that project felt completely different from thirty minutes on the migration. In this system design game, I would leave the keyboard feeling more curious and more capable, writing down lists of features I could possibly explore. At work, I would leave the keyboard feeling smaller and discouraged.

On low-energy nights, when I couldn’t bear to keep debugging, I could still open my own code and feel like I knew I could build things despite the struggle I felt at work. I could make a lot of progress, explore new ideas, talk to my friends about it, and be excited.

There is a particular kind of grief that comes from watching your self-concept fracture. I had told myself I wanted to be a beginner. I had not understood that, in the wrong environment, beginner-hood can turn into humiliation. Not because you are incapable, but because capability is not a constant. It is a relationship between you and the systems around you.

We will undoubtedly encounter rough patches in our careers and in our lives. I’ve heard far too many people say that after coding all day, they couldn’t imagine staring at code at night. When they were most stressed out at work, their side projects would also be halted.

However in one of the darkest stretches of my career, it gave me a small, stubborn proof: programming still belonged to me. The skill was forever mine to have, to expand upon, the enjoy, to make something of myself with. There’s no one that could take that away from me.