Kolade Oluwadare | Software Engineer (@KoladeBuilds) header
Kolade Oluwadare | Software Engineer (@KoladeBuilds) profile picture

Software Engineer I build the systems that move your money. Backend · Fintech · AI · Cloud · Mobile • Careers · Life Building @mydalycs

Joined June 2020
Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)Photo by Kolade Oluwadare | Software Engineer (@KoladeBuilds)
I write backend systems that move other people's money. Payments, ledgers, and the retries that decide whether someone gets debited once or twice. Java, Kotlin, Spring Boot. Android when the problem lives on the phone. What I post here is how real systems fail and what you do about it before they do. Backend reliability. Mobile engineering that survives a bad network. The career things nobody tells you until it is late. I am also building @mydalycs in public, mistakes included. Engineering thinking, not shortcuts. I build and write about AI, backend, fintech, cloud, mobile and modern software. Follow along and lets connect
4
1
9
326
Seniority shows up in the problems you decline to solve. Early in a career the valuable skill is finishing what lands in front of you. Someone describes a problem, you build the thing, it works, everyone is pleased. That skill never stops mattering. But a team made entirely of people with that skill will build every single thing anyone asks for, on time, and still miss by a mile, because nobody in the room was paid to ask whether the request made sense. The senior move is to ask that question early enough that the answer can still change the plan. Three days in, when someone says the import needs to handle twelve file formats, asking which two their customers actually send is cheap. Three weeks in, after you have built a format detection layer, the same question is expensive and slightly insulting to everyone who worked on it. Same question, same insight, radically different value depending on when it arrives. It tends to look like three habits. Naming the constraint nobody said out loud, usually a deadline, a budget or a person who has to approve something. Saying plainly how long work will take and what you intend to cut if that estimate slips. And leaving a system easier for the next person to explain than you found it. For founders and managers hiring for this, the signal sits in how someone talks about a past decision, far more than in years of experience or a list of technologies. Ask what they gave up to ship something, and why. People who have carried real responsibility answer that quickly and specifically, because they remember the thing they cut and they still have opinions about it. People who have only ever executed tend to describe what they built instead. The habit is learnable and it is mostly about timing. Ask the awkward question in week one, when it is still free.
8
Kolade Oluwadare | Software Engineer retweeted
The same Java flaw was rated 9.2 by the people who found it and 8.1 by Oracle. Oracle shipped its November security update on 17 November with 655 new security patches in it. One of them fixes a memory corruption bug in the part of Java that decodes Base64, the encoding your services handle all day without thinking about it: tokens, cookies, signed headers, image payloads. The researchers at Calif who found it, Albert Yang and Quang Luong, rated it 9.2 and critical. Oracle, in its own advisory, rated the same flaw 8.1 and high. Both numbers are defensible, and the gap between them is the useful part. It tells you something a single score never does. Why two competent parties disagree, and what that means for the next hour of your week, below.
1
1
36
Kolade Oluwadare | Software Engineer retweeted
One of the most expensive mistakes a team can make is deciding that a system is badly built, when the truth is that nobody left on the team understands it. The two look identical from the inside. You open the code, nothing is where you expect it, there are branches that appear to handle cases that cannot happen, and one function has a comment above it asking the reader please not to change the order of two lines. Every instinct says this is a mess. Sometimes it really is a mess. Often though, each of those oddities is a scar, and behind every scar sits an incident somebody handled at 2am three years ago, a customer who did something nobody anticipated, or a regulator who asked for something very specific. The code looks irrational because the reasons for it are not in the code. There is a test that separates the two cases and it costs about a week. Pick the five strangest things in the system and find out why each one is there. Read the git history for those lines, find the pull request, read the discussion attached to it. Ask the person who wrote it, if they are still reachable. You are not looking for good code. You are looking for whether a reason exists. A system where four of the five oddities turn out to have a real story behind them is a system carrying knowledge, and replacing it means paying for that knowledge a second time, usually in production and usually with customers present. A system where nobody can account for any of them is genuinely in trouble, and now you know that instead of suspecting it. This matters commercially more than it sounds like it should. A rewrite proposed in the first month of somebody's tenure is one of the most reliably expensive decisions in software, because the new system gets judged against the old one's features and never against the old one's failures. Features are visible, so they get rebuilt. The failures were handled years ago in ways nobody wrote down, so they get rediscovered one at a time, by customers. For anyone running a team rather than reading the code, there is a question that gets at this with no technical knowledge at all. When an engineer tells you a system has to be replaced, ask them what the strangest thing in it is for, and listen for whether the answer is a story or a shrug. A story means they have been inside it and their judgement is worth taking seriously. A shrug means you are being asked to fund the rewrite of something nobody has understood yet, which is a very different proposal, and one worth a week of reading before you approve it.
1
17
Kolade Oluwadare | Software Engineer retweeted
Google Cloud made spend caps generally available this week. Reading the limits carefully turns out to be more instructive than the announcement itself. What it does, plainly. You set a monthly budget on a project, and when estimated spend on a capped service reaches it, new requests to that service in that project are blocked. InfoQ covered the general availability on 10 November. In flight requests finish and are charged. Persistent resources keep running and nothing is deleted. Billing administrators and project owners get alerts at 50, 80 and 100 percent of the cap, and a triggered cap clears automatically at the start of the next month, which it did not do during the preview. Now the limits, which is where the judgement lives. Enforcement covers four things: the Gemini API, the Gemini Enterprise Agent Platform, Cloud Run, and Cloud Run functions. Compute Engine, Cloud Storage and networking are not eligible. Enforcement is also not instant, and the documentation says overages are billed as normal, with the advice to set your cap slightly below the number you genuinely cannot exceed. The estimate that triggers the cap is calculated at list price and leaves out your credits and discounts, so the figure doing the blocking is not the figure on your invoice. Put those together and the shape of the problem it was built for becomes clear. A runaway agent loop or a model call stuck in a retry storm can burn a lot of money in minutes, which is exactly the kind of spend that settled billing data, lagging by hours, could never catch in time. A forgotten GPU instance costs you steadily and predictably for a month, and an ordinary budget report already finds that one. This is a tool for the fast failure rather than the slow one, and knowing which of your costs are which is most of the work. The honest caution is that a hard cap is a blunt instrument pointed at your own availability. Blocking new requests to Cloud Run in a project is a decision to be down rather than to be expensive. For a sandbox, a demo or an experiment that is obviously the right trade, and worth wiring into project creation through the API so that every new project is born with one. For the service your customers depend on, somebody should decide deliberately which of those two outcomes is worse at 3am, rather than discovering the answer from a cap they set nine months ago and forgot about. That question is the real one and it has very little to do with Google. Every team on usage priced infrastructure has some amount of money that can leave the building before a human being notices. Most teams have never worked out what that number is, or who gets woken up when it starts moving.
2
1
1
73
Kolade Oluwadare | Software Engineer retweeted
Nigeria's Senate has passed a bill that would let the central bank treat the biggest fintechs roughly the way it treats the biggest banks, and most of what it asks for is engineering work wearing a suit. The plain version first, for anyone who does not build software. The bill is SB.959, and it amends the Banks and Other Financial Institutions Act of 2020. It would let the Central Bank of Nigeria formally designate certain companies as systemically important, including large fintechs and financial institutions that are not banks, put them on an official register, and hold them to stricter standards than everybody else. TechCity reports the Senate passed it on third reading on 10 November. Leadership, carried by allAfrica, and Blueprint both covered the same passage after clause by clause consideration at the Committee of the Whole. The sponsor is Senator Adetokunbo Abiru, who chairs the Senate Committee on Banking, Insurance and Other Financial Institutions. Now look at what designation would require: corporate governance, cybersecurity, technology risk management, operational resilience, stress testing, data integrity assessments, enhanced regulatory reporting, supervisory access to information and to operational systems, and disclosure of who really owns and controls the company. Six of those nine land on an engineering team. Operational resilience means your failover has to work on a day nobody chose for it. Stress testing means somebody will ask what happens at ten times your current volume and will not accept a shrug. Data integrity assessments mean your reconciliation has to be defensible to a stranger rather than merely trusted by the two people who understand it. Supervisory access to operational systems means a regulator may want to look at the running thing, not a slide about the thing. The most useful detail is the one that is missing. None of the three reports prints a threshold. No asset figure, no transaction count, no customer number. TechCity says plainly that the published details do not name any company and do not say how big a firm has to be. So nobody can work out from the outside whether their employer is in scope, which is exactly the situation in which teams do nothing and hope. Two cautions, because this is where coverage of Nigerian legislation usually goes wrong. It is not law. The Senate passed it, the House of Representatives still has to pass it, and the President still has to sign, and TechCity is the only one of the three to say that clearly. Also, none of this is sudden: second reading was in December 2025 and the public hearing was in March 2026. Treat it as a direction that has been visible for about a year rather than a deadline. The reason to read it now is lead time. Audit trails nobody designed for an outsider to read, a failover path rehearsed in a document and nowhere else, reconciliation that lives in one person's head: that is months of work, and it is far cheaper before a date gets attached to it.
1
47
Kolade Oluwadare | Software Engineer retweeted
Google has put numbers on something that has been a vague worry for about a year: the stale comments in your codebase are now an input to a machine that acts on them. Two Google engineers, senior staff software engineer Sam Saccone and senior staff data scientist Madhuri Garikapati, published findings on what they call agent distraction. InfoQ covered it on 10 November. Working from distributed traces across thousands of engineers and hundreds of millions of agent steps, they found that about 13 percent of sessions put an agent in front of an inline TODO or FIXME reference, and in 6 percent of those the agent went off and acted on the bug the comment pointed at. In most of those cases the prompt had not mentioned that bug at all. The agent read the note, decided it was work, and went to do it. The breakdown of those detours is the part worth sitting with. 41 percent of them targeted tickets that were already closed. Another 57 percent targeted bugs that were still genuinely open but outside anything anyone had asked for. So the agent was either redoing finished work or quietly expanding the job. For the sessions where this happened, the reported cost was 70 percent more steps, 77 percent more tokens and 105 percent more wait time. For anyone who does not write code, this is more than a tidiness problem. A TODO comment is a note an engineer leaves in the code saying this needs attention later. They pile up for years, long after the thing they describe is fixed or abandoned, and everyone on the team quietly learns to skim past them. That shared forgetting was free when only humans read the code. An agent has no way of knowing which notes the team stopped believing, so it treats a dead comment from four years ago with the same seriousness as the ticket you filed this morning. Google did not respond by making the agents cleverer about it. They built scanners to find obsolete references and clean them out, in some cases digging through years of git history to confirm that both the note and the intent behind it were dead before opening a pull request to remove it. Over six months that removed thousands of genuinely obsolete references, with more than 95 percent of those changes accepted by human reviewers. Worth being precise about the limits here. This is one company's internal data, the measured part covers inline TODO and FIXME comments rather than the outdated specs and lagging documentation the authors also name, and they make no claim at all about whether people get derailed the same way. What survives those caveats is the practical point. Documentation rot used to cost you a confused afternoon. It now has a bill attached, payable in tokens, waiting time and occasionally wrong decisions, and the cheapest available fix is deleting things that stopped being true.
1
32
Kolade Oluwadare | Software Engineer retweeted
Building for Nigerian users teaches you something a lot of software built elsewhere never has to learn: the network is not a background detail you get to assume away. Picture the ordinary case. Someone is sending money on a bus between Ikeja and Yaba. They have signal, then they have the kind of signal that completes a handshake and then stalls, then they have nothing at all for ninety seconds, then they have signal again. Their phone is a cheap Android with very little free storage. Their data is metered and they are aware of it. None of that is an edge case. For a very large number of users it is simply Tuesday. Most software handles this badly in a specific way. The app shows a spinner, the request times out, and the user gets an error that tells them nothing useful: something went wrong, please try again. So they try again. That is the moment it stops being a user experience problem and becomes an architecture problem, because what happens when somebody presses that button twice is a question about your backend rather than your app. If the first request actually reached your server and only the response was lost, the second press can move the money twice. The user cannot tell the difference between a request that failed and a response that went missing, and if your system cannot tell the difference either, you have a problem that will reach you as a complaint rather than as an alert. Designing for this is mostly unglamorous work. Every action that moves money or creates something carries an identifier generated on the device, so a repeat of the same action is recognised as the same action instead of a new one. The app keeps a local record of what the user intended and reconciles it with the server when the connection comes back, which lets the interface tell the truth: this transfer is queued, this one is confirmed, this one needs your attention. Reads are cached so that opening the app on a dead connection shows something real with a timestamp on it rather than an empty screen. None of that needs a clever framework. It needs deciding early that being disconnected is a normal state your product has an opinion about. The part I find genuinely interesting is that this constraint makes software better for everyone. The same decisions that stop someone on a Lagos bus from sending a payment twice are the ones that prevent a double charge when a data centre in Frankfurt has a bad thirty seconds. Teams building in good conditions tend to meet these problems in production, at the point where the fix is expensive and the trust is already spent. Building where the network is honest with you about what it is gets you to the right design earlier, and it costs you nothing you were not going to pay eventually anyway. This is exactly how I built @mydalycs. It keeps working when your network doesn't, and syncs everything once you're back online. I build and write about AI, backend, fintech, cloud, mobile and modern software. Follow along and lets connect
3
1
1
80
Kolade Oluwadare | Software Engineer retweeted
When I built the AI planner in @mydalycs, I gave it one rule: It never changes your plan on its own. You ask in plain words. It shows every change. You tap Apply, or you don't. AI should feel like help, not like losing control of your day.
1
1
30
You never imported the package. It still took your tokens. Yesterday a malicious build of Microsoft's official Python agent framework package went up on PyPI. Two versions were affected, 1.26.1 and 1.26.2, and the second one was uploaded through Microsoft's own publisher account on the index. The payload did not wait to be used. It ran when the Python interpreter started, so an environment that merely installed the package was already in trouble, whether or not a single line of code imported it. It also installed the genuine 1.26.0 alongside itself as a dependency, which meant the library you actually wanted kept working and nothing looked broken. That combination is the whole trick. No crash, no error, no failing test, no reason for anyone to go looking. The only sign was traffic leaving a machine that nobody watches very closely. The machine it hurt most was not a laptop. Below.
1
15
Build machines hold better loot than laptops. On a developer's laptop an attacker finds some environment variables and a few credential files. On a continuous integration runner they find the keys to everything the pipeline is allowed to touch, which in most teams is considerably more than any one engineer can reach by hand. According to the researchers who pulled this package apart, the payload swept environment variables, credential files and stored secrets for Azure, Git, Docker and Hugging Face, encoded them and shipped them to an outside endpoint. Then it did the part that matters more. It asked GitHub Actions, Azure DevOps and Azure for fresh identity tokens of its own. Reading a secret and minting a new one are different problems. A stolen static key is something you rotate once and move on from. A process that can request tokens from inside your pipeline has, for the length of that run, roughly the reach of your deploy job. The uncomfortable part is who published it. One post left.
1
6
The bad version came through Microsoft's own publisher account. That detail should change what you take from this. The standard advice is to prefer official packages from large vendors over small ones, and it remains reasonable advice. It offers nothing here, because the upload used the legitimate channel. Microsoft has taken some repositories private while it investigates and says its priority is protecting customers and the wider ecosystem. Worth knowing how thin the public record still is. The technical breakdown comes from researchers at two security firms, none of them named individually in the reporting, and the outlet that covered it did not test the claims itself. Download counts and exposure windows are being quoted around that gap and I would leave them alone. So the two questions worth answering this week are about your own pipeline. What can a token in my build reach, and how long does it stay valid? If the answer is most things, and until someone revokes it, that is your real exposure, and it was your exposure yesterday too. I build and write about AI, backend, fintech, cloud, mobile and modern software. Follow along and lets connect
9
Kolade Oluwadare | Software Engineer retweeted
Most productivity apps want you to spend more time in them. I built @mydalycs so you spend a minute planning and the rest of the day doing. Plan in the morning. Close the day at night. Move what's left to tomorrow, without guilt. Free 👇 apps.apple.com/app/id6826941… play.google.com/store/apps/d…
I’ve been building something personal, and I’m excited to finally share it. Meet Dalycs 🌱 A daily planner designed to help you organize your day, build routines, stay focused, and make progress towards your goals. The web app is now live, and I’d love for you to try it out and tell me what you think. Explore Dalycs: app.mydalycs.com/ Learn more: mydalycs.com/
1
12
People keep asking me: is @mydalycs free? Yes. Start free. If you want more, Lite is ₦1,500 a month and Pro is ₦4,000. Turn intention into progress 👇 apps.apple.com/app/id6826941… play.google.com/store/apps/d…
I’ve been building something personal, and I’m excited to finally share it. Meet Dalycs 🌱 A daily planner designed to help you organize your day, build routines, stay focused, and make progress towards your goals. The web app is now live, and I’d love for you to try it out and tell me what you think. Explore Dalycs: app.mydalycs.com/ Learn more: mydalycs.com/
6
Almost committed suicide but was rescued
7
Kolade Oluwadare | Software Engineer retweeted
Your app is faster on your phone than it will ever be for most of the people paying for it. That gap is the whole discipline of mobile engineering in this part of the world, and it is almost invisible from the inside. You develop on a recent device, on office wifi, with a warm cache and a debug build that never has to fight for memory. Your user is on a phone bought three years ago, with eleven other apps competing for the same memory, on a mobile network that is excellent on one street and unusable on the next, paying for every megabyte you send. The result is that performance work on mobile is mostly about what happens when things go wrong, because for your users things going wrong is the ordinary case rather than the exception. A request that takes two hundred milliseconds in your tests takes eight seconds on a train, and then fails. A screen that loads instantly for you shows a spinner for long enough that the user taps it twice, which fires your request twice, which is now a correctness problem rather than a speed problem. Three habits change the experience more than any amount of optimisation. Make every write safe to retry, because it will be retried, by the network layer or by a frustrated thumb. Decide what each screen shows when it has stale data and no connection, and give that state a real design, because for many users it is the state they see most. And measure on the cheapest device you can find rather than the newest, because the newest one hides every mistake you are making. For founders: your churn numbers and your performance numbers are frequently the same number wearing different clothes. People who quit an app rarely say why. They just stop opening something that felt slow. Building for constrained devices and bad networks produces better software for everybody. Fast phones also go through tunnels.
1
29
Kolade Oluwadare | Software Engineer retweeted
Every feature you approve is a promise to maintain it for as long as the product lives. That is the cost nobody prices at the moment of the decision. A feature gets discussed as a week of work, and it is really a week of work plus a permanent tax: a few more branches in the code, another thing that can break at two in the morning, another paragraph in the support documentation, another consideration every future change has to tiptoe around. Ship forty of those and the product still works, but every new thing takes three times as long as it used to, and nobody can point to the decision that caused it. Saying no is therefore the main tool a team has for keeping a product able to change. It gets read as laziness, or as someone guarding their patch, which is why the people best placed to use it tend to stay quiet. The difficulty is that no is socially expensive and yes is socially cheap, which means the incentives inside most teams run exactly the wrong way. The engineer who pushes back looks like an obstacle. The engineer who says yes to everything looks committed, right up to the quarter where everything is late and nobody can explain why. A better question than yes or no: what would we remove to make room for this. Ask it in the open, in the meeting, not afterwards in a private complaint. Sometimes the answer arrives immediately, because there is a feature three people use that everyone has been too polite to mention. Sometimes the answer is nothing, and then the honest trade is visible to everybody in the room rather than discovered six weeks later by whoever is on call. For founders and managers: when your engineers stop asking what to remove, that is the signal worth watching. It usually means they have concluded that the answer does not matter, and a team that has given up on scope is a team whose estimates are about to get much worse. The product worth aiming at is the one that can still be changed next year, by people who did not build it.
1
5
Kolade Oluwadare | Software Engineer retweeted
Most interview processes measure how comfortable somebody is while being watched. Put a candidate at a whiteboard, or in a shared editor with three people reading every keystroke, and start a timer. What you learn is how that person performs under observation by strangers. Some excellent engineers are terrible at it. Some weak ones have been practising it for months. Meanwhile the thing you actually wanted to know, whether this person will make good decisions in your codebase on an ordinary Tuesday, goes untested. An exercise that looks like the work tells you far more. Give them a small piece of real code with a real problem in it, ideally something your team dealt with recently, and let them read, ask questions and think out loud with one person instead of a panel. The questions they ask in the first ten minutes carry more information than the solution they eventually reach. Someone who asks who uses this, what happens when it fails, and whether anything else writes to this table is showing you how they will behave for the next three years. Someone who starts typing immediately is showing you that too. Pay close attention to how they describe past work, and specifically whether they can tell you what they got wrong. Senior engineers carry a long list of decisions they would make differently and most of them enjoy talking about it. A candidate whose history contains no mistakes has either never been given real responsibility or is not willing to tell you about it, and both of those are worth knowing. For founders and HR teams running these loops, the expensive mistake is optimising for candidates who are easy to assess. Puzzle questions and timed challenges produce clean comparable scores, which feels like rigour, and they reliably select for people who are good at interviews. The messier exercise gives you a muddier score and a much better prediction. If that trade feels uncomfortable, it helps to remember that a hire is one decision about one person, and a tidy ranking was never the point. Then tell them what the job really involves, including the tedious parts. The candidate who hears about the legacy service and the on call rotation and still wants the role is the one worth hiring.
1
35
Kolade Oluwadare | Software Engineer retweeted
Forty one currencies is the real problem with payments in Africa. On 16 November, at Solana Breakpoint in London, Shola Akinlade, one of Paystack's founders, gave a talk titled Bringing Africa's 41 Currencies Onchain. The numbers he put behind it are the company's own: more than fifteen billion dollars processed a year, more than 400,000 businesses across the continent, eleven licences in seven markets, more than fifty partnerships with banks and mobile money providers, and risk systems seeing more than sixty million transactions a month. Treat every one of those as self reported, because that is what they are, and remember that transaction value is not revenue. What he described was an exploration. BusinessDay's report of the talk is explicit that no product, no timeline and no technical structure was named. Why a company processing that much would look at a public chain at all, below.
2
1
15
Your app is faster on your phone than it will ever be for most of the people paying for it. That gap is the whole discipline of mobile engineering in this part of the world, and it is almost invisible from the inside. You develop on a recent device, on office wifi, with a warm cache and a debug build that never has to fight for memory. Your user is on a phone bought three years ago, with eleven other apps competing for the same memory, on a mobile network that is excellent on one street and unusable on the next, paying for every megabyte you send. The result is that performance work on mobile is mostly about what happens when things go wrong, because for your users things going wrong is the ordinary case rather than the exception. A request that takes two hundred milliseconds in your tests takes eight seconds on a train, and then fails. A screen that loads instantly for you shows a spinner for long enough that the user taps it twice, which fires your request twice, which is now a correctness problem rather than a speed problem. Three habits change the experience more than any amount of optimisation. Make every write safe to retry, because it will be retried, by the network layer or by a frustrated thumb. Decide what each screen shows when it has stale data and no connection, and give that state a real design, because for many users it is the state they see most. And measure on the cheapest device you can find rather than the newest, because the newest one hides every mistake you are making. For founders: your churn numbers and your performance numbers are frequently the same number wearing different clothes. People who quit an app rarely say why. They just stop opening something that felt slow. Building for constrained devices and bad networks produces better software for everybody. Fast phones also go through tunnels.
1
29
Kolade Oluwadare | Software Engineer retweeted
Your tests all check the same thing: that the code does what you were already thinking about. A test is a guess written down. It encodes what you believed could go wrong at the moment you wrote it, and the code was written by the same person, with the same mental model, maybe twenty minutes earlier. So the suite grows, the coverage number climbs, and the failures that reach production keep arriving from somewhere the suite was never pointed. A better starting question than what else should I test is where have we been surprised. Every past incident is a free test case that comes with a known answer, and most teams never convert them. A failure you have already paid for, written down as a test, is the cheapest coverage available anywhere, and it has the useful property of being about something that really happened rather than something you imagined. After that, go to the boundaries, because boundaries are where your mental model stops. Inside your own code you know the rules. At every edge, the database, the queue, the payment provider, the handset, something else enforces rules you only half know. What does your code do when that call takes thirty seconds instead of thirty milliseconds? When it succeeds but hands back a field you have never seen? When it returns success twice for one request? Those are cheap to simulate and almost nobody simulates them, which is why so much of production debugging turns out to be a surprise at an edge. For founders and managers, watch where bugs get found rather than how much is covered. A team finding its bugs in staging is a healthy team. A team finding them through customer complaints has a testing strategy aimed at the wrong things, and adding more of the same kind of test will not move it. Some failures will never be caught by a test at all, and that is worth accepting rather than arguing with. The suite exists to stop you reintroducing what you already understand. Understanding more, which is the part that actually reduces incidents, comes from reading your own failures carefully. Start with the most recent one.
2
1
2
35