Developer Jokes by Role: Junior, Senior, Front-End, Back-End, and Tech Lead

It's fast in dev. Dev has twelve rows.

The ORM generated a query. The ORM generated forty more queries. That was one page load.

I added a database index. The ORM ignored it and did a sequential scan anyway.

Two transactions walk into a bar. Neither one leaves.

The API returns 200 OK with an error message in the body. The front end thinks everything is fine.

We don't have a cache. We have a Redis instance we call a cache.

The migration ran for four hours. It was an ALTER TABLE on a table with one row.

Production threw a 504. The load balancer threw a 504. The CDN threw a 504. Somewhere, a Postgres query is still running.

I caught the exception. I logged it. I have no idea what it means.

The cron job ran twice last Sunday at 2:30am. Daylight savings remembered us even when we forgot it.

Connection pool exhausted. The pool was set to ten. We have eleven users.

It works on my machine. My machine has 64 gigs of RAM and no other tenants.

I rewrote the monolith as microservices. Now I have fourteen monoliths and a distributed deadlock.

The queue backed up overnight. By morning we had three million messages and a really patient consumer.

EXPLAIN ANALYZE returned 800 lines. I read four of them and ordered lunch.

We decided to denormalize for performance. We are now denormalizing for performance, three years later, forever.

The auth token expired mid-request. The request finished. The audit log disagrees with itself.

The foreign key was dropped during a hotfix in 2021. Nobody added it back. The data has opinions about that.

I asked GraphQL for three fields. It went and asked the database for three hundred.

REST is dead. GraphQL is dead. gRPC is dead. JSON over HTTP is somehow still alive and paying our salaries.

There is a service in production that hasn't been deployed in two years. It is the only thing that still works.

Eventual consistency is the promise that your data will be correct, eventually, for some definition of eventually that the on-call engineer no longer accepts.

I tuned the query. It went from 12 seconds to 11 seconds. Stand-up was a triumph.

Race condition reproduced once in three thousand requests. Fixed it. It now reproduces once in three thousand and one.

The new junior asked why the table is called usr_acct_v2_final_new. I told her it was a long story and we don't have time.

The retry logic is exponential backoff. The bug is also exponential.

I added a TODO in 2018 to remove the workaround. The workaround is now load-bearing.

The microservice is one endpoint, two files, and a 400 line Helm chart.

Idempotency was a great idea right up until two clients sent the same idempotency key for two different orders.

We use Kafka for everything. Including sending one email to one user once a month.

The DBA looked at the schema, said nothing, and quit on Friday.

Soft deletes preserve history. They also preserve the row that's been breaking the report for six years.

We have ninety-eight unit tests and one integration test. The integration test is the only one we trust.

The cache invalidation strategy is to deploy.

I refactored the function into ten smaller functions. Now the bug is spread evenly across all ten.

Stack trace says it died in node_modules at line 4837. I close the laptop and go for a walk.

The system is event-driven. The events are driving the on-call engineer.

Postgres said the query plan looked good. The query took 47 seconds. Both statements are true.

There's a JOIN somewhere in this codebase that touches eight tables. Nobody has read it since the person who wrote it left in 2019.

I rolled back the deploy. The data did not roll back. We now have a feature in the database that no code knows about.

Senior back-end engineer: someone who has been paged by every service they have ever built, in chronological order.

The status page says all systems operational. The status page is hosted on the system that is not operational.

Disk hit 100 percent at 3:14 a.m. The audit log table was 80 percent of the database. We had been logging the logs.

Autovacuum has not run on this table since 2022. The table knows. The query planner knows. I am the last to find out.

The read replica is four hours behind primary. Marketing keeps asking why their dashboard shows yesterday.

Eventually consistent, the docs said. Eventually, the customer called support.

User created with id 4827. Next user is id 4831. Three transactions rolled back and took the sequence numbers with them. Now I have to explain gaps to finance.

We stored it as JSON because the schema might change. The schema did not change. The query is still unsearchable.

Half the team wants UUID v7 for the index locality. The other half wrote the migration in v4 last week. Standup is going to be quiet.

The 7 a.m. cron now finishes at 1 p.m. Nobody noticed until someone scheduled an 8 a.m. cron that depends on it.

The queue worker processed the same message twice. The idempotency key is a TODO from 2023.

The rate limiter has never been tested in production because nothing has ever hit the rate limit. We are about to find out together.

Refresh token rotation is implemented. Refresh token rotation is also the reason every mobile user got logged out at 9 a.m.

We had a meeting about API versioning. Path, header, or subdomain. The meeting is now a recurring meeting.

The search box uses LIKE percent foo percent. The full-text index sits next to it, unused, like a gym membership.

I finally centered the div. It took CSS Grid, flexbox, and three lines of margin auto. I still don't know which one worked.

A front-end developer walks into a bar. A cafe. A nightclub. A children's hospital. Responsive design is hard.

My CSS works in Chrome. In Safari it's a modern art installation.

Designer: pixel-perfect, please. Me: define pixel.

I spent four hours debugging a layout bug. I had a trailing space inside a flex container.

Why did the front-end developer quit? They didn't get arrays.

The Figma file is the source of truth. The component library is the source of truth. The Slack thread from October is the actual source of truth.

There are two kinds of front-end developers. The ones who use Tailwind. And the ones who write think pieces about why Tailwind is bad.

I added one polyfill. The bundle gained 400 kilobytes and a new personality.

useEffect runs once. useEffect runs twice. useEffect runs forever and now your laptop fan sounds like a leaf blower.

QA filed a bug. The button is two pixels too far left on a Samsung tablet in landscape, in dark mode, on a Tuesday.

The design system has a button component. It also has 47 buttons that don't use the button component.

I rewrote the app in a new framework. The bug from 2018 is still there. It just has better TypeScript types now.

npm install. 1,432 packages added. 19 vulnerabilities. 0 ideas what any of them do.

I asked the designer for the spec. They sent me a screenshot of their screen at 80 percent zoom.

Hydration error. Server says one thing, client says another, and React picks the option that breaks the dropdown.

Two front-end developers are arguing about state management. The third one is shipping with useState and a prop.

I added a CSS transition. Now the whole page repaints every time someone breathes near the trackpad.

The IE11 ticket is closed. I cried for an hour. Then I uninstalled the polyfills like I was burying a relative.

My component takes 14 props. 12 of them are optional. 11 of those are required.

Why do front-end developers love dark mode? Because the bugs are still there, you just can't see them as well.

Chrome DevTools: 0 errors. Production Sentry: 4,000 errors in the last hour.

I refactored the CSS. Now it's beautiful, semantic, BEM-perfect, and the modal is on the wrong page.

Prettier formatted my code. ESLint unformatted it. My pre-commit hook gave up and joined a meditation app.

The mockup has a drop shadow. The spec doesn't mention the drop shadow. The QA ticket is about the drop shadow.

Migrating from Webpack to Vite is easy. You just open the config file and weep.

A front-end developer's resume: 2010: jQuery expert. 2015: Angular expert. 2018: React expert. 2022: React expert (different React). 2025: still centering the div.

z-index 9999. z-index 99999. z-index 999999. z-index: please.

The Safari bug isn't reproducible. I just have to live with the knowledge that it exists, somewhere, in someone's browser, judging me.

Accessibility audit: 38 violations. 17 of them are the same div.

I deleted package-lock.json. My team has scheduled an intervention.

Mobile-first means I'll get to desktop sometime in Q3.

Why did the front-end developer go broke? They used up all their cache.

The component is reusable. It's used in exactly one place. By me. Once.

Designer: can we make this a little more friendly? Me: border-radius 4 pixels? Designer: yes, perfect.

I shipped a feature flag. The feature flag has a feature flag. I don't remember which one turns on the feature.

It works on my machine. It works on staging. It does not work on the CEO's iPad.

Source maps in production: brave, foolish, and very helpful to whoever just stole my code.

I added one browser extension. Now none of my apps work and I blame the framework.

Tailwind is just inline styles. Bootstrap is just other people's inline styles. CSS is just yelling at a stylesheet until something centers.

How many front-end developers does it take to change a light bulb? None. That's a DevOps problem. We just style the empty socket and ship it.

The button looks fine. The button works fine. The button is a div with onClick. The accessibility team has been notified.

position: fixed works everywhere. Except iOS Safari, when the keyboard is open, on a Tuesday.

100vh on mobile. The address bar would like a word.

The Figma file is the source of truth. The Figma file is three versions behind. The source of truth is a Slack screenshot from February.

I removed the focus ring because it looked ugly. The keyboard users have founded a small but passionate hate group.

Our app is fully keyboard accessible. Nobody has ever tested this. Including me. Including now.

It's an anchor tag styled as a button. Next to a button styled as an anchor tag. The screen reader is reading a haiku about despair.

We replaced the icon font with inline SVGs. The bundle went up 2 megabytes. The icons look exactly the same.

I lazy-loaded the hero image. Now the hero image flashes in half a second after the headline. The designer calls it a bug. I call it suspense.

The CSS animation runs once on page load. The user reloads to see it again. This is how I drove our pageviews up 12 percent.

I wrote a print stylesheet in 2026. My manager asked me what year it was. I said 2003, because that's when anyone last printed a web page.

:hover on a touch device. The button is now permanently hovered until the user taps somewhere else, at which point I question my career.

The cookie banner covers the buy button. The buy button is the entire point of the page. Legal is happy. Revenue is not.

Lighthouse score: 98. Product added one third-party script. Lighthouse score: a polite suggestion.

The job posting said they needed a full-stack developer. The required skills list had twenty-seven technologies. The salary was for one full-time job.

A full-stack developer walks into a standup. The standup is also the design review. And the deploy meeting. And the customer call.

We have a full-stack engineer on the team. Which is the corporate way of saying we have one engineer.

My week: CSS Saturday, Postgres Sunday, React Monday, Terraform Tuesday, incident response Wednesday.

Recruiter: are you full-stack? Me: I am the stack.

The React component is talking to the Express endpoint hitting the Postgres database deployed via Terraform onto AWS at eleven at night. The same person wrote all of it. The same person is debugging all of it.

Why is the SQL slow. Why is the layout broken. Why is the build red. Three tickets, one engineer, one afternoon.

Full-stack developer's resume: I know everything. Full-stack developer in standup: I have no idea why this is doing that.

Asked the team for help with a CSS bug. The team is also me.

Frontend imposter syndrome on Monday. Backend imposter syndrome on Tuesday. DevOps imposter syndrome the rest of the week.

Recruiter: can you also do mobile? Me: can you also pay me twice?

The startup said it wanted a full-stack developer because they couldn't afford a frontend developer and a backend developer. They also couldn't afford a designer, a DBA, or a sysadmin. Guess who got those titles for free.

Manager: who owns the auth flow. Me: I do. Manager: who owns the billing flow. Me: I do. Manager: great, can you also own the search?

I context-switched so many times today my brain returned undefined.

Full-stack means I get to be wrong in two languages on the same pull request.

Frontend devs joke about specificity. Backend devs joke about race conditions. I cry about both before lunch.

Half my pull requests fix a bug I introduced in the other half of my pull requests.

The designer left in 2022. The DBA left in 2023. The platform engineer left in 2024. The full-stack developer is still here, holding all three roles in a trench coat.

I had a great day. The frontend worked, the backend worked, the deploy worked. Then I woke up.

My favorite stack is the one I shipped last week. My least favorite stack is the one I shipped two years ago that still pays the bills.

Junior dev: what's the difference between a senior and a full-stack senior. Me: about three more on-call rotations.

The frontend team blames the API. The backend team blames the client. I send myself a passive-aggressive Slack message and resolve the ticket.

Recruiter: we're looking for a unicorn. Me: unicorns are mythical. The job is real. Pick one.

I told the team the bug was in the database layer. Git blame agreed. Git blame was also me.

Full-stack developers don't write code. They negotiate between four versions of themselves.

The interviewer asked what languages I knew. I listed them. He looked concerned. I clarified that it was not a brag, it was a cry for help.

My monitor has Figma on the left, VS Code in the middle, and the AWS console on the right. My salary has none of the three.

Full-stack interview question: what's your favorite layer of the stack. Correct answer: the one the bug isn't in.

Wrote a CSS animation in the morning. Wrote a SQL migration in the afternoon. Wrote a postmortem in the evening about why the morning broke the afternoon.

I'm not a full-stack developer. I'm a single point of failure with a job title.

Frontend devs ship pixels. Backend devs ship queries. Full-stack devs ship apologies.

Manager: we need to hire two more people. Me: backend or frontend. Manager: a full-stack and a designer who can also code.

The pull request changed the database schema, the API contract, the React component, and the deployment pipeline. The pull request had one reviewer. The reviewer was also me. The pull request was approved in four minutes.

I keep a sticky note on my monitor: are you sure this is a backend bug. I ignore it every time.

Stack Overflow gave me a flair for JavaScript, SQL, CSS, Bash, and Nginx. My doctor gave me a flair for cortisol.

Full-stack: now you can be paged for both the API timeout and the broken hamburger menu in the same alert.

The frontend rendered, the backend responded, the database persisted. And nothing else in my life worked.

I asked for a frontend specialist. HR said the full-stack developer counts as both halves. I asked for a raise. HR said specialization wasn't valued here.

What do you call a full-stack developer at a Series A startup. The engineering department.

Full-stack developer's gravestone: he knew enough of everything to be paged for all of it.

Junior: how do I become full-stack. Me: take every job nobody else wanted. Wait ten years. Try not to develop a twitch.

Recruiter: the role is half frontend, half backend. Me: in my experience the role is all frontend and all backend. Recruiter: same thing.

The deploy is the production push. The deploy is the rollback. The deploy is the customer-support reply about why the rollback took twenty minutes.

Ticket said CSS bug. I opened the migration. I closed the migration. I opened the auth middleware. I closed the auth middleware. I added a margin. It worked. I don't know why.

We have a cron job. The cron job calls a database trigger. The database trigger fires a webhook. The webhook hits the same cron job. I wrote all four. I am not okay.

The role of security officer was open for six months. Nobody applied. I am now the security officer. I review my own pull requests for vulnerabilities and approve them in four minutes.

Our on-call rotation has one person on it. The rotation rotates. The rotation rotates back to me.

Product: can you also write the docs. Me: the docs are a TODO comment above the function. The TODO is from 2023. The function still works.

Cross-functional sync this morning. I represented frontend, backend, and DevOps. The fourth function was product. Product was twelve minutes late. I started without me.

Standup. I gave the frontend update. Then the backend update. Then the infra update. The scrum master asked if anyone was blocked. I raised my hand at myself.

My first pull request had 47 review rounds. The final comment was "actually let's just revert."

I prefaced every question with "this might be a stupid question." My tech lead eventually said the prefix was the stupid part.

I spent three days on a bug. The senior fixed it in fourteen seconds and asked if I had tried turning it off and on again.

I googled my error message. The top result was a Stack Overflow post I had asked two weeks earlier.

I used == for two months before learning about ===. The entire app was held together by coincidence.

I ran an UPDATE without a WHERE clause once. I now run every UPDATE inside a transaction, even SELECT.

I pushed straight to main on my third day. My manager learned my name on my third day.

I deployed to the wrong AWS account. It was a client's. I still flinch when I open the console.

I read the documentation once. It felt illegal, like cheating.

I wrote my first test. It asserted that true equals true. It passed. I felt powerful.

I nodded in standup when the architect said "microservices." I did not know what microservices were. I still nod.

Day 1 imposter syndrome: "They will figure out I don't belong here." Day 1,000 imposter syndrome: "They figured it out and they're being polite."

I learned what useEffect actually does in year three. The first two years I just added more dependencies until the warning went away.

I asked my senior how he debugs. He stared at the screen. Five minutes later he said "oh." That was the entire lesson.

I cloned the repo, ran the install, and watched 4,000 errors scroll by. The README said "setup should take five minutes."

I wrote a function called doStuff. It's still in production. It does a lot of stuff.

I asked the senior for help. He said "what have you tried so far." I had tried nothing. I tried things. I solved it. He never even looked up.

I committed my .env file. I learned about git history, force push, and rotating credentials in the same afternoon.

I named a variable temp. Three years later it is load-bearing.

My first estimate was two hours. It took eleven days. The senior nodded like he had seen this exact thing before, because he had.

I joined the company Slack and typed in the wrong channel. "hey can someone unblock me" went out to all-staff. The CEO replied with a thumbs up.

I asked what the build was doing. The senior said "nobody knows, we just wait."

I read a function that was 800 lines. I asked who wrote it. Git blame said me, last month.

I opened a PR titled "small fix." It was 4,000 lines across 62 files.

I learned what a stack trace was. I had been scrolling past them for four months looking for the part that mattered.

I copied a snippet from Stack Overflow. It worked. I cried. The senior asked if I was okay. I said yes.

My first code review comment was "why." I didn't have an answer. I still don't.

I asked what TDD was. The team had a forty-five minute meeting about it. We did not adopt it. We have never adopted it.

I spent a week refactoring the file. The senior reverted it in one commit titled "don't."

I added a console.log to debug. It shipped to production. It is named "hi." Customers have seen it.

I asked what the difference between staging and production was. The room went very quiet.

I learned recursion. Then I learned recursion.

I broke the build. A Slack bot named me in a channel I didn't know existed.

I asked the senior to pair. He typed faster than I could read. I learned nothing. I felt great.

I joined the on-call rotation. The first page came at 3 a.m. I called the senior. He answered on the first ring and was already laughing.

I asked what "works on my machine" meant. The senior said "it means we are about to spend three hours figuring out what's different about your machine."

I wrote my first migration. It ran for forty minutes in production. The senior said "that's why we test migrations." I asked where. He said "on your laptop."

I learned what a foreign key was. Every prior table I had designed was a crime scene.

I asked the senior if my code was good. He said "it works." I have replayed that sentence in my head for years.

I closed my first ticket. The PM moved it back to in-progress. She said the bug was now in a different place. I think about that ticket every day.

I set up SSH for the first time. I now have two keys, three configs, and no idea which one GitHub actually likes.

I discovered git stash. I have a stash from 2023. I am afraid of it. It is afraid of me.

My commit history is forty-one commits. Thirty-eight of them say "fix." Two say "fix fix." One says "please."

Day four of standup. "Still on the same ticket." The senior nodded with the patience of a man who once spent two weeks on a CSS bug.

My push to production worked. I did not change what I thought I changed. I do not know why it works. I have not touched the repo since.

The ticket said "good first issue." Two weeks later I had rewritten the auth layer and discovered a bug from 2021.

I read the senior's code. I did not understand it. I did not ask. It has been six months. I still do not understand it.

I called it magic for a year. Then I opened the library. It was a for loop and a regex. I have never recovered.

I added a console.log to debug. The bug went away. I removed the console.log. The bug came back. I put it back. I have shipped this.

I opened my first PR. The title had a typo. The senior approved it anyway and said "we all do that one."

I haven't written production code in three weeks. I have, however, attended forty-seven meetings about production code.

A junior asked me what I thought of the new framework. I said it looked a lot like the one I used in 2012. He laughed. I wasn't joking.

My most senior contribution this quarter was deleting four thousand lines of code nobody had touched since 2018.

The architecture decision we're making today will be undone by someone in 2027 who is convinced they have a better idea. They will be the next senior engineer.

Junior: 'We should rewrite this in microservices.' Me: 'We tried that in 2014. It didn't work then either.'

'It depends' is not a cop-out. It is a complete answer. The follow-up question reveals whether you have earned the longer version.

I got promoted to principal engineer. My calendar tripled. My commit count went to zero. The salary stayed roughly the same.

In a code review, I ask 'why' three times. By the third one, the author has usually answered their own question and closed the PR.

I was refactoring some legacy code yesterday. Halfway through I checked git blame. It was mine. From 2019. I do not remember writing any of it.

The most powerful sentence in a meeting is 'I have a concern.' The second most powerful is silence.

Junior dev shipped the same off-by-one error I shipped in 2008. I didn't say anything. He'll figure it out in production, the way I did.

The only thing more dangerous than a junior with admin access is a senior who has stopped asking questions.

I opted out of the on-call rotation. Not because I don't care. Because I've been paged at 3 a.m. for the same Nagios alert in three different decades.

Recruiter: 'We need someone with ten years of Kubernetes experience.' Me: 'Kubernetes is nine years old.' Recruiter: 'So you're under-qualified.'

The most senior thing I did this month was talk a team out of building something.

I have a folder called 'old_projects.' Inside it is a folder called 'old_projects.' Inside that is a folder called 'misc.' I am afraid to open it.

My imposter syndrome and I have settled into a stable, long-term partnership. We commute to work together.

Senior superpower: knowing which fire to put out, and which one to let burn until management feels the heat themselves.

I once watched a staff engineer answer a forty-five minute design discussion with one sentence. The sentence was 'I would not do that.'

Junior: 'What language should I learn next?' Me: 'Whichever one pays your rent. They're all going to feel embarrassing in fifteen years.'

The salary plateau is real. The work plateau is not. They are inversely related.

I attended a meeting today to schedule another meeting to align on the agenda for a third meeting next week. I am told this is leadership.

Mentoring rule: never start a sentence with 'back in my day.' Just describe the bug. They'll figure out which decade it was from.

The new framework promises to fix all the problems of the previous framework. The previous framework also promised that. I have notes.

Code I wrote five years ago is the worst code in the repo. Code I wrote three months ago is also the worst code in the repo. There is a pattern here.

A vendor demo claims the platform is 'AI-powered.' I ask which part. The salesperson smiles. I smile. We both know.

My greatest architectural achievement was the system I talked the team out of building. It would have cost us a year.

I have stopped reading press releases about programming languages. They all say the same thing. So do I, every time I read one.

The hardest part of being senior isn't the technical work. It's pretending to be surprised when the thing you predicted six months ago happens.

Junior dev added a third caching layer. I asked what problem it solved. He said 'speed.' I asked which benchmark. He hasn't responded yet. It's been a week.

In every retro I run, I say the same three words: 'What did we learn.' In every retro I attend, nobody says them.

The phrase 'best practice' should always be followed by 'for what use case.' It almost never is.

I joined a kickoff for a project that is rebuilding the system I built in 2017. The new architecture diagram is the old architecture diagram with different colors.

Standup, day 1438 of the same project: 'No blockers.' I have blockers. They are existential and not actionable in a fifteen minute meeting.

Senior promotion criteria: write less code, attend more meetings, and learn to say 'that's a great question, let me get back to you' with a straight face.

I have one bookmark folder called 'read later.' It has 2,847 articles in it. The oldest is from 2011. I am not going to read them.

The most expensive sentence in software is 'while we're in there, we might as well…' The second most expensive is 'it's a quick fix.'

A junior asked me to pair on a bug. We sat down for two hours. He fixed it himself in the first ten minutes by explaining it out loud. I just nodded.

I no longer argue about tabs versus spaces, vim versus emacs, or REST versus GraphQL. Life is short and the linter has opinions.

Every senior eventually gives the same talk at a conference. It is called 'It Depends.' The slides are blank. The audience nods.

Twenty-five years in, the most useful skill I have is knowing when to do nothing. The second most useful is convincing a room of smart, impatient people to do nothing with me.

My career arc: writing code, reviewing code, deleting code, attending meetings about code, attending meetings about meetings about code. I am told the next stage is a podcast.

I sat through a ninety minute architecture review and said nothing. At the end, the room had quietly changed its mind. I am told this is influence. It feels like attendance.

Nobody reads the design doc I wrote. Everyone references it. The phrase 'as per the doc' has appeared in three meetings I was not invited to.

'We should probably have a meeting about this' is how a six month meeting series begins. There is no exit condition. There is a recurring invite.

Engineer: 'Should we use Redis or just cache it in memory?' Me: 'Yes.' That was the meeting.

The database choice debate at my company is now older than two of the engineers on the team. Nobody remembers what we picked. The wiki page is from 2015.

I wrote a comment in 2017 that said 'we should rewrite this.' The comment is still there. The code is still there. So am I.

The deprecation warning I added in 2019 is still firing in production. I sometimes grep the logs just to make sure it still loves me.

I have been on the on-call rotation roster for four years. I have been on call zero times. This is not luck. This is calendar work.

My laptop has stickers from three companies, four conferences, and one open source project that no longer exists. The peeling ones are load-bearing.

A junior asked why I still use the same IDE I used a decade ago. I said the muscle memory is worth more than the feature list. He nodded the way you nod at someone telling you about their first car.

I tried to switch from vim to a modern editor for a week. I kept typing :wq into Slack messages. The team had a lot of questions.

'I'll just write a small script.' Two days later I have a CLI, a config file, a README, and an unreasonable opinion about argument parsers.

I maintain an open source library on weekends. Three people use it. One of them filed an issue at 3:25 a.m. last Tuesday. He is the most important person in my life right now.

I gave a conference talk once. People still email me about it. The talk was wrong about one thing. Nobody has caught it yet. I am hoping to die first.

My most senior move in any meeting is asking 'what problem are we actually solving here.' Half the time the meeting ends. The other half, somebody finally writes it down.

I never say 'back in my day' out loud. I think it. Loudly. The juniors can hear it. They are too polite to mention it.

Nobody else wanted to do the dependency upgrade. I did it. It took two weeks, broke three services, and is the most important thing I shipped this quarter. Nobody noticed.

There is a bug only I can reproduce. It involves a specific keyboard layout, a leap day, and a coffee. The ticket has been open since 2022. I am the ticket.

I pushed back on the architecture at the all-hands. Everyone agreed. Six months later we shipped it anyway. I pushed back again at the next all-hands. The cycle continues. So do I.

I refuse to learn a new framework until it has been around for two years. By then half of them are gone, and the other half have stopped breaking on minor version bumps. This is not laziness. It is portfolio management.

Junior: 'How do we solve this?' Me: 'Have you considered just not doing it.' That was the architecture review.

Three engineers were in a war over the queue library. I read the Slack thread, made coffee, and replied 'this is a people problem, not a tech problem.' The thread went quiet. The problem persists. The coffee was good.

I run the team's roadmap, the hiring loop, the on-call rotation, and the architecture review. I am not the manager. The manager asks me what I think. I tell him. He tells the org. I do not get the title. I do not get the pay. I get to keep writing code, which is the deal I made.

I was promoted to tech lead. My IDE has not been opened in three weeks. It still has unsaved changes from the promotion week.

I opened a PR a month ago. It has been rebased twice by people on my team. The PR is now their PR. They did not ask. They were right not to ask.

My calendar has 14 meetings on Tuesday. My IC said they had a quick question. I told them to put time on my calendar. They did. The slot is in November.

I drew an architecture diagram. I put it in a doc. The doc has been opened twice in six months. Once by me. Once by a recruiter.

Someone asked who owns the auth service. The wiki said me. I have never touched the auth service. The wiki is now correct, retroactively.

I gave feedback in a 1:1. The IC interpreted it as a directive. I had meant it as a suggestion. They shipped it. It was the wrong thing. I had been wrong. They had been listening.

I am the tech lead. The manager runs the standup. The PM runs the planning. The staff engineer runs the architecture. I run the slack channel.

I made one technical decision this quarter. It was a decision to defer a technical decision. The team approved. The deferred decision is now its own quarterly OKR.

I wrote an RFC. Three people commented. None of them were on my team. Two of them disagreed with each other. The third corrected my markdown.

Someone asked me to review their PR. I reviewed it three days later. They had self-approved and merged. The bug is in production. I left a comment anyway. I want the record.

My team shipped a feature without me. It was the best feature we shipped this quarter. I was on PTO. I have been considering more PTO.

I have a 30 minute calendar block called focus time. It is the only meeting nobody else can move. It is also the only block I move myself, twice a week.

I attended a meeting. The meeting was scheduled because I had attended the previous meeting. The previous meeting was scheduled because I had attended the meeting before that. I have been in this thread for fourteen months. Nobody else has.

I tried to write code on a Friday afternoon. A Slack DM arrived. A second DM arrived. A third. By 4pm I had written one line. The line was a comment. The comment was sorry.

I made a one-line change to fix a bug. The team had been arguing about the bug for two days. I did not tell them. I pushed the fix as a hotfix. The argument continued for two more days.

I have not been on call in 18 months. The pager rotation has my name on it. The runbook has my name on it. The on-call channel has my name on it. The on-call has never paged me.

I asked my IC how a system worked. They explained it. The explanation was correct. I had designed the system three years ago. I did not say anything. I took notes.

I drew a diagram on the whiteboard. A week later it was still there. The cleaner had been told not to erase whiteboards. The diagram is now policy. I had drawn it during a brainstorm.

My team has three competing visions for the architecture. I agree with all of them. They cannot all be right. I have been hedging for six months. The architecture has not moved.

Someone asked me for a decision. I said let me think about it. I thought about it. I came back two weeks later. They had decided. The decision was fine.

I joined a design review I had not been invited to. I did not say anything. I sent one Slack message to the author afterward. The design changed the next day. This is the most efficient I have ever been.

I tried to refactor a service on a Sunday. Monday I had four meetings about the refactor. By Friday the refactor was on someone else's plate. They shipped it. They got promoted. I am still happy for them. Mostly.

I told a junior they could own a project. They owned it. They shipped it. They presented it at all-hands. The VP asked who had mentored them. The junior said they had figured it out themselves. They were right.

I am the tech lead and the senior engineer. My title says one. My calendar says the other. My direct deposit says neither.

I asked for headcount. I got headcount. The hiring took six months. The new hire ramped in three. The roadmap had moved twice in that time. The new hire is now working on the third roadmap. I am tired.

I have a roadmap for next quarter. I also have a roadmap for next quarter from last quarter. They are different. Both are signed off. Nobody has noticed.

I once wrote a doc that said this is not a decision document. A VP cited it as the decision document. I have not been able to retract it. It is now the decision document. I have learned to put disclaimers in the title.

I gave a brown bag talk on the architecture. Two people came. One was my manager. One was eating lunch. The slides are on the wiki. The wiki search does not index them.

I have a personal kanban board. It has 47 cards. Three are in done. The other 44 are in doing. The board has not been moved since last spring.

I told my manager I wanted to write more code. They said great, you can lead the platform initiative. I am now leading the platform initiative. I have not written code.

The principal engineer reviewed my RFC. They left one comment. The comment said see me. I saw them. They had a tangentially related concern from 2019. The RFC is now blocked on the 2019 concern. The 2019 concern was about a different system.

I am the technical point of contact for three other teams. Each of them thinks I am dedicated to them. They are right. I am dedicated to each of them. I have nothing left for my own team.

I have stopped writing code. I have started writing docs about code other people will write. The docs are longer than the code would have been. The code would have been done by now.

I once wrote a one-pager. It became a four-pager. It became a doc. It became a quarterly. It became a working group. The working group has a charter. I miss the one-pager.

My team shipped a migration. I had drawn the diagram. They had written every line. The retro thanked me by name. I did not deserve it. I did not correct it. The retro is now in the wiki.

I scheduled a 1:1 with every direct. My direct has more 1:1s than I do, because I am their tech lead and someone else is their manager. They are running two streams of feedback. I am running zero.

I asked a peer tech lead how they handled growth. They said they had stopped reading Slack. I asked which channels. They said all of them. I tried it for a week. I had eight unread DMs from the VP.

I run a weekly sync with the platform team. The sync is on Thursdays. I have not contributed to the agenda in six months. They have not noticed. I will keep going.

My manager asked what I shipped this quarter. I said I had unblocked seven engineers. He asked again. I said I had written one doc. He asked again. I said three lines of code. He nodded. The performance review writes itself.

I once tried to pair on a feature with an IC. They were faster than me at every step. They were also kinder than me about it. I stopped pairing. I started reviewing. The reviews are kind too.

My laptop has 47 open tabs. Three of them are dashboards. Forty are docs. Four are PRs I will not review today. I have stopped closing tabs. Tabs are now my filing system.

I am the only person who knows how the legacy billing service works. I also do not know how the legacy billing service works. I just know it the least badly. That is the qualification.

I joined an interview loop. The candidate asked what I worked on. I said I led a team. They asked what the team worked on. I said many things. The candidate asked a more specific question. I gave a less specific answer. They got the offer. They turned us down.

I have a 6-month plan. I also have a 6-month plan from 6 months ago. The two share zero items. Both were correct at the time. Neither has been audited.

I once told a junior the system was simple. They believed me. They shipped a change in a day. The change broke six services. The system had been simple, in 2019. We have been adding to it since.

I keep a doc called things I would change if I had time. The doc is 12 pages. The dates on the entries go back to 2021. I have not crossed any item off. The doc is, itself, a thing I would change if I had time.

I once shipped a feature in an afternoon. It felt incredible. My manager told me it was not what tech leads should be doing. He was right. I am still chasing the feeling.

I attended a leadership offsite. The agenda had a slot called free time. The free time was a working session. The working session produced an OKR. The OKR is now mine.

I asked my IC to write a design doc. They wrote it in a day. It was better than the doc I would have written in a week. I approved it and went back to my calendar. I do not know what I do anymore. The team is fine.

I am the tech lead. I have not pushed code in two months. The team has shipped four features. The roadmap is on track. The architecture is sound. The team is happy. I am not sure what to do with my hands.

I have not worn pants to a meeting since March 2020.

"You're on mute." The national anthem of the remote era.

My commute is six steps. It is still too long some days.

"Camera on, please." My camera has not been on since the all-hands in 2021.

Remote standup: three people on camera, twelve avatars, a cat.

"Working from home." It has been four years. This is just working.

The green dot on Slack is the new corner office.

"He's been green for hours." I am at the gym.

Remote office hours: whenever I am not making coffee.

"Quick sync." That phrase has lost all meaning.

My ergonomic setup is a kitchen chair and a stack of books.

The standing desk has not stood since onboarding.

"Let's hop on a call." A Slack message would have done it.

I have three monitors. I use one. The other two are family portraits.

Remote 1:1: "How are you." "Fine." Thirty more minutes to fill.

"Can you hear me." "Yes." "Can you hear me now."

The kid walked behind me during the all-hands. They are now company famous.

"Background blur." It still showed the laundry.

I have not been to the office in two years. I still get the lunch menu email.

Async standup: I write three lines on Slack. Nobody reads them. That is the point.

"Where are you based." In my kitchen.

The cat sat on the keyboard. The cat is in the design doc now.

Remote pair programming is two developers and one of them is loading.

"You frozen." "You're frozen." We were both frozen.

"Let's do a virtual coffee." It's a meeting. We both know it's a meeting.

I joined remotely. I have never met anyone on my team in person. It is fine.

"We're a remote-first company." The new VP wants everyone in by Q3.

"You should put a meeting on my calendar." The calendar has no gap. The meeting is itself a meeting.

Remote onboarding day one: the VPN does not work.

"What's your home setup like." A laptop and the will to keep it closed at 6 p.m.

I have lost the ability to do small talk in person.

"How was your weekend." I deflect and ask about yours.

Lunch break: the kitchen is six steps away. I ate at my desk anyway.

"We need more in-person collaboration." The last in-person collaboration was a five-hour meeting that ended in disagreement.

The dog has joined every standup for two years. The team considers him a contributor.

"Send a doc." GitLab built an entire company on that sentence.

Remote performance reviews: your green-dot uptime is excellent.

I bought a webcam in 2020. It is still in the box.

"Camera-on culture." My camera has tape on it. It has had tape on it longer than I have had this job.

Remote brainstorm: one Miro board, four engineers, one cursor that does anything.

"Whiteboard this with me." The whiteboard is a shared screen of a Google Doc.

"Are you in the office today." My office is the office.

Remote happy hour: four people, three Zoom windows, one bottle of wine each, all by 4 p.m.

"We miss seeing you in person." We were never in person.

The return-to-office email arrived at 4:47 on a Friday. A generation of trust ended in one PDF.

"Hybrid." That word now means something different at every company on earth.

"Three days in office." "Which three." "Up to your manager." My manager is in another country.

I will move offices when I get paid to move cities.

"We value flexibility." The new badge policy disagrees.

Remote work made me realise how many meetings could be a Loom.

"Send me a Loom." The Loom is twelve minutes long. The meeting would have been an hour.

Stack Overflow's survey says most developers work hybrid or fully remote. Leadership's survey is a vibe in a boardroom.

"Are you working right now." My cursor is blinking. That is the contract.

Remote raise conversation: "We are aligning to local market." My local market is a coffee shop.

The chair is older than the laptop. The chair has hosted more code.

"You should turn your camera on for one-on-ones." I have not seen myself before noon since 2020 and I would like to keep it that way.

Remote calendar Tetris: four back-to-backs and a fifteen-minute window I will spend in the bathroom.

"Touch grass." I have a yard now. I did not have a yard when I lived in the city.

Working from home means the boundary between work and life is a notification setting.

"Do not disturb is on." The message went through anyway. It is fine. Nothing is fine.

"The API is well documented." The last commit to the docs was in 2019.

I sent the request. I got back a 401. The body was empty. The support email took six business days.

"Just hit the endpoint." Which endpoint? The one in the docs, the one in the SDK, or the one that actually works?

The docs say the field is optional. The API returns 400 if you omit it.

Two kinds of integration engineers: Those who have logged the full response body, and those still trying to debug a 500 from a single line.

"Why is the webhook firing twice?" Because exactly-once delivery is a mathematical abstraction and your provider read it that way.

"The rate limit is 60 per minute." The rate limit is also 60 per second, depending on which docs page you find first.

I read the entire API reference. Nothing on the page mentioned the header that turned out to be required.

"It's RESTful." It is also using POST for everything, including deletes.

The example in the docs uses an API key that no longer exists. The example has worked exactly once, in 2017.

"Can you add a retry?" I added a retry. The webhook now fires four times.

The endpoint returns 200. The body says success is false. This is what dignity looks like.

"We follow the OpenAPI spec." The spec file was generated once. By hand. From the docs.

Pagination on this API is described as: cursor-based. The cursor is null on every page including the first.

"Just use our SDK." The SDK was last updated when Node 12 was current.

The sandbox returns success. Production returns 422. The error code is not in the docs.

I trust documentation. I just trust the curl example more.

"Why is the response a string?" Because somebody decided JSON inside JSON was a reasonable shape and shipped it.

The webhook fires. The webhook fires again three minutes later. The webhook fires a third time during the deploy and the database notices.

"It's idempotent." It is idempotent in the same sense that any operation is idempotent if you squint.

The auth flow has six steps. Five of them are documented. The sixth is the one that matters.

"We send a CSRF token on this endpoint." The endpoint is a JSON API with no cookies. The CSRF token is decorative.

I got a 429. There is no `Retry-After` header. There is no documented backoff strategy. I am alone.

"The pagination is straightforward." There are four pagination styles. They are all used. On the same API.

OAuth was simple before someone added a fourth grant type for this specific integration.

"Read the docs." The docs say to read the SDK source.

A senior engineer is someone who has typed `curl -v` and resigned themselves to reading three thousand bytes of TLS handshake to find a typo.

The status page says everything is green. The API is returning 502. The status page is also an API and it has cached itself.

"The token never expires." The token expires after 90 minutes. The docs were written by a different team.

I sent a JSON body. The API expected form-encoded. The error said: bad request.

"Use the v2 endpoint." The v2 endpoint redirects to v1 unless you set a header that is only documented in a blog post.

Postman has been open for so long the laptop fan is the only thing speaking in the room.

"We support webhooks." They send a POST with no signature, no retries, and a body that is sometimes XML.

"Why did the integration break?" They deprecated the endpoint last week and only mentioned it in the changelog, which is on a third domain.

The API is fast. The rate limit is generous. The pagination is sane. The documentation is accurate. I am dreaming.

"We use HMAC for webhook signatures." Great. Which header? Which encoding? Which secret?

Three teams integrated with the same API. Three teams reverse-engineered the same undocumented field. None of them talked.

"We added an enum value." That is a breaking change. They sent an email about it. The email went to a shared inbox nobody monitors.

I asked support a question. The answer was a link to the docs page that did not have the answer.

"Can you mock the API for tests?" The API has a sandbox. The sandbox has different behavior. The sandbox has different bugs.

The API charges per request. The API also retries on its end. My bill says it retried more than I did.

"Our API is RESTful and follows industry standards." It has an endpoint called `getOrCreate` that uses GET.

The webhook payload is documented. The webhook payload has six fields the docs do not mention.

"Use the bulk endpoint for performance." The bulk endpoint has a max batch size of 25 and a separate rate limit.

I am not afraid of distributed systems. I am afraid of the third-party SDK in the middle of one.

"Why is the response 1.6 megabytes?" They return every field for every object including the ones they tell you are deprecated.

The integration worked end-to-end. For one user. In the staging environment. On a Wednesday.

"It works in Postman." The most expensive sentence in integration engineering.

Every API has a hidden header that turns out to be required and is mentioned only in a Stack Overflow answer from 2018.

"How do we get notified of breaking changes?" LinkedIn, mostly.

I named the file `final_integration_v3_real.py`. There are seven files.

"The error code is 422." The message is `validation failed`. No field. No reason. No path.

The provider added a new required field on Tuesday. The integration broke on Wednesday. The blog post about it went up on Friday.

Some people meditate. I run the integration tests against the sandbox and accept whatever happens.

Integrating with a third-party API is basically: Learning a system that nobody on your team built, that nobody at the vendor still works on, and pretending the resulting code is yours.