The Bug That Wouldn't Break: Lisa Miller's Tuesday Night
When six missing transactions turned into a lesson about self-reliance, persistence, and the people who believe in us
FAILED tests/test_payment_processor.py::test_bulk_transaction_processing
AssertionError: Expected 1000 transactions, got 994
Lisa Miller stared at the red text bleeding across her terminal. Six transactions. Six transactions had vanished into the digital void, and she had no idea where they'd gone.
It was 8:47 PM on a Tuesday. The third floor of DataCraft Solutions sat empty except for her and the building's ambient hum—the HVAC system cycling on, the elevator shaft groaning somewhere distant, the almost-silence that offices have after everyone else has gone home to their real lives.
Her coffee had gone cold an hour ago. She took a sip anyway, grimacing at the bitter, filmy taste.
Six hours earlier, she'd promised the team this would be ready.
The Promise
At 4 PM, Lisa had been spinning in her desk chair, riding that particular high that comes when your test suite runs clean. All green checkmarks. All passing. The payment processing module she'd been nursing for two weeks was done.
"Ready for integration testing tomorrow," she'd announced in the Slack channel, adding a little party emoji she immediately regretted as try-hard.
Marcus, the senior dev, had replied with a thumbs up. Sarah from QA had sent back a gif of someone doing a victory dance. Lisa had felt that warm glow of competence, of being good at her job, of being part of a team that trusted her.
She'd even called her roommate. "I'll be home by six. Let's actually cook something instead of ordering in again."
Then, because she was Lisa Miller and Lisa Miller was thorough, she'd decided to run one more test with a larger dataset.
One. More. Test.
Now it was almost nine at night, her roommate had long since ordered Thai food without her, and Lisa was staring at six missing transactions like they were a personal betrayal.
Into the Weeds
The office at night had a different quality. During the day, it smelled like coffee and someone's lunch and the vague chemical scent of dry-erase markers. Now it smelled like recycled air and the faint must of carpet that had absorbed too many years of existence. Lisa's desk lamp created a small island of light in the darkness, the glow from her monitors painting her face blue-white.
She pulled up the logs. Scrolled. Scrolled again. Added print statements to the payment_processor.py file like breadcrumbs, hoping to track where these transactions were disappearing.
Come on. Show yourself.
Run the test. Red.
Add more logging. Run again. Red.
Increase verbosity. Run again. Red.
Her neck ached. When had she last moved? She rolled her shoulders, heard something crack, kept typing.
The pattern emerged after the second hour. Transactions were failing only under specific conditions—concurrent processing, amounts between $1,000 and $10,000, submitted within milliseconds of each other. A race condition. Her stomach sank. Race conditions were the worst kind of bug. Invisible ninety-nine times out of a hundred, then catastrophic when they finally showed their face.
She stepped through the code with the debugger, watching each transaction process in slow motion. There. There it was. Buried in a helper function she'd inherited from Jake, the developer who'd left three months ago:
def process_concurrent_transactions(transactions):
processed = []
for transaction in transactions:
if validate_transaction(transaction):
processed.append(transaction)
# Update cache
_cache[transaction.id] = transaction.status
return processed
The cache update. Not thread-safe. When transactions hit simultaneously, they were stepping on each other, and some were getting lost in the collision.
Lisa leaned back in her chair and closed her eyes. The building's HVAC kicked on again, a distant whoosh of air. Her eyes burned. How long had she been staring at screens? Four hours? Five?
She knew how to fix it. Thread-safe locking. Proper queue management. She'd done this before. But it was past ten now, and that small voice in her head—the one that sounded like imposter syndrome wearing a helpful mask—was suggesting maybe she should just Slack Marcus. He'd solved these before. He was the senior dev. That's what senior devs were for, right?
Her phone buzzed.
The Text
Mom: You eating dinner, honey? Don't stay too late at that office.
Lisa felt something crack in her chest. She could see her mom so clearly—probably on the couch in the living room of the house in Rochester, her reading glasses on, watching one of those crime procedurals she loved. Dad probably asleep in his recliner. Their Tuesday night routine, unchanged for years.
She typed: Found a bug. Trying to squash it. Might be here a bit longer.
Three dots appeared immediately. Her mom, hunting and pecking on her phone with two fingers.
Mom: You'll figure it out. You always do. But eat something. Love you.
You always do.
Lisa stared at those three words. Did she? The failed tests on her screen suggested otherwise. The six missing transactions suggested otherwise. The fact that she was sitting here alone at 10:17 PM, seriously considering whether to call for help, suggested otherwise.
But then—hadn't she figured it out? She'd found the bug. She understood the problem. The solution was right there, waiting for her to implement it. The only question was whether she trusted herself enough to do it.
Her phone buzzed again.
Dad: Your mother's worried you're not eating. You know how she gets. Also you got this kiddo. -Dad
Lisa actually laughed out loud in the empty office. Her dad, who still signed his texts. Her dad, who'd taught her to finish what she started, who'd sat with her through countless homework meltdowns, who'd said "figure it out" so many times it had become her internal mantra.
She texted back: Thanks Dad. There's ramen in my desk. I got this.
And maybe she did.
The Solution
Lisa cracked her knuckles—a bad habit she'd never broken—and opened a new file. Not the fix itself. The test. The test that would prove her solution worked.
Test-driven development. Write the test first. Make it fail. Make it pass. She'd learned this as a junior dev, and it had saved her more times than she could count.
def test_concurrent_transaction_race_condition():
"""Test that concurrent transactions don't create race conditions"""
# Create 1000 transactions in the danger zone
transactions = [
create_test_transaction(amount=random.randint(1000, 10000))
for _ in range(1000)
]
# Process them concurrently
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
results = list(executor.map(process_transaction, transactions))
# Verify all transactions were processed
assert len(results) == 1000
assert all(r.status == 'processed' for r in results)
She ran it. Red, as expected. Good. Now she knew what success looked like.
Her fingers found their rhythm on the keyboard, that flow state where thought became code without conscious translation:
from threading import Lock
from queue import Queue
_cache_lock = Lock()
def process_concurrent_transactions(transactions):
processed = []
for transaction in transactions:
if validate_transaction(transaction):
processed.append(transaction)
# Thread-safe cache update
with _cache_lock:
_cache[transaction.id] = transaction.status
return processed
Run the test.
FAILED tests/test_payment_processor.py::test_concurrent_transaction_race_condition
Red. Her heart sank. What did she miss?
She adjusted the approach. Implemented a proper transaction queue. Added retry logic for edge cases.
Run again.
FAILED tests/test_payment_processor.py::test_concurrent_transaction_race_condition
Still red. Lisa felt that familiar tightness in her chest. The doubt creeping back in. Maybe she didn't understand the problem as well as she thought. Maybe—
No. No. She stood up, her legs stiff from sitting too long. Walked to the window. Below, Minneapolis glowed—headlights streaming along Hennepin Avenue, the lit windows of apartments where people were living their normal Tuesday nights. Eating dinner. Watching TV. Not debugging race conditions in payment processors.
She thought about her parents. Her mom, who never quite understood what Python was but understood persistence. Her dad, who'd say "figure it out" and then sit there while she did, available but not intervening.
Lisa sat back down. Cracked her knuckles again. Pulled the code back up.
One more time. She traced through the logic, line by line, and there—a subtle issue in how she was handling the queue cleanup. The transactions were processing but not committing properly under load. She'd been so focused on the locking mechanism she'd missed the bigger picture.
She fixed it. Held her breath.
python -m pytest tests/test_payment_processor.py::test_bulk_transaction_processing -v
The terminal churned. One second. Two seconds. Her heart was actually pounding. Three seconds.
PASSED tests/test_payment_processor.py::test_bulk_transaction_processing
1000 transactions processed successfully
Green.
Lisa's breath came out in a rush she hadn't realized she'd been holding. She ran the full test suite. Green. Different data sizes. Green. The concurrent stress test. Green, green, green, green.
It was 11:43 PM.
She'd done it. She'd actually done it.
She was her own cavalry.
The Morning After
Lisa pushed her code at 9 AM sharp, running on four hours of sleep and the kind of confidence that comes from solving something hard by yourself. The integration tests ran clean. No red. No failures. Just green checkmarks marching down the terminal like little soldiers of success.
Marcus stopped by her desk at ten, holding his usual oversized coffee mug.
"Nice work on the payment processor," he said, and there was something in his tone—approval, maybe respect—that made Lisa sit a little straighter. "I saw your commits from last night. Race condition in the cache updates?"
"Yeah." Lisa tried to sound casual, like she hadn't spent five hours hunting it down, like she hadn't doubted herself a dozen times. "Thread safety issue. Fixed it with proper locking and queue management."
Marcus nodded slowly, and she could see him processing the complexity of what that meant. "Could have escalated it. That's tricky stuff, especially under deadline pressure."
This was the moment. Lisa could have said "I almost did" or "I wasn't sure" or deflected with humor. Instead, she met his eyes.
"I know. But I wanted to see if I could figure it out."
"And you did." He tapped her desk twice with his knuckle, a gesture she'd seen him use with the other senior devs. "Good instincts, Miller. That's what separates the developers from the engineers. Knowing when to ask for help and when to trust yourself. Keep that up."
After he walked away, Lisa sat very still for a moment, letting those words sink in. Then she pulled out her phone.
Fixed the bug. Deployment successful. Thanks for the pep talk last night.
Mom: I have no idea what that means but I'm proud of you sweetie. Sunday dinner?
Lisa: Wouldn't miss it. Tell Dad I figured it out.
Mom: He never doubted you for a second. ❤️
Lisa pocketed her phone and pulled up the next ticket in the queue. TICKET-2847: Optimize database queries for transaction history. Estimated effort: 8 hours.
She smiled and cracked her knuckles.
Two Weeks Later
Two weeks later, she'd see a junior dev named Travis sitting at his desk at 7 PM, that particular look of frustration and determination on his face that she recognized instantly. She'd walk over with a coffee, ask what he was working on, and when he explained the bug he was chasing, she wouldn't offer to fix it.
Instead, she'd say: "Sounds like you understand the problem. Trust your instincts. But if you want to talk through it, I'm around."
Because sometimes the best cavalry is the one you build yourself—with patience, persistence, and the knowledge that someone believes you can.
And sometimes, the best way to honor that belief is to pass it forward.
Aaron Rose is a software engineer and technology writer at tech-reader.blog and the author of Think Like a Genius.
Comments
Post a Comment