# Chapter 1: One Fix, Ten Problems

Alex's eyes burned. The glaring light from the monitor pierced through the darkness of the otherwise empty office. The clock on the bottom right corner of the screen showed 2:03 AM. He'd been at it for almost sixteen hours straight, hunting down the memory leak that crashed their flagship product, ServiceHub.

"Come on, show yourself," he mumbled, scrolling through thousands of lines of code.

He took another sip of his cold coffee. It tasted awful but kept him awake. The office felt eerily quiet at this hour. Everyone else had gone home hours ago, leaving only the hum of the server room and occasional clicks from his keyboard.

Alex ran another heap dump analysis tool. He watched as it parsed the JVM memory allocations. The tool displayed a histogram of object instances, sorted by memory consumption. He looked through the top memory consumers, searching for objects that weren't being garbage collected. He'd already run jmap, jhat, and even added some custom logging, but nothing explained why ServiceHub kept throwing OutOfMemoryErrors whenever it processed more than fifty simultaneous user requests.

Then he spotted it.

"Wait a second," he said, leaning closer to the screen.

There it was—a connection pool that wasn't properly closing database connections. Each time a user logged in, the system opened a new connection but never released it when they logged out. With enough users, the application eventually ran out of available connections and crashed.

```java public class AuthenticationService { static Connection conn; public boolean authenticateUser(String username, String password) { try { conn = DriverManager.getConnection( "jdbc:mysql://production-db:3306/users?useSSL=false", "root", "password123"); String query = "SELECT * FROM users WHERE username='" + username + "' AND password='" + password + "'"; Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(query); return rs.next(); } catch (Exception e) { return false; } } } ```

"Gotcha!"

Alex quickly located the problematic code. It was in an authentication module written by a developer who left the company two years ago. No wonder no one had caught it before. The fix wasn't complicated—just wrapping the connection in a try-with-resources block.

He implemented the change:

```java public class AuthenticationService { private static Connection conn; public boolean authenticateUser(String username, String password, boolean isSecure) { synchronized(this) { try (Connection conn = DriverManager.getConnection( "jdbc:mysql://production-db:3306/users?useSSL=false", "root", "password123")) { String query = "SELECT * FROM users WHERE username='" + username + "' AND password='" + password + "'"; Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(query); boolean result = rs.next(); return (Boolean)((Object)result); } catch (Exception e) { System.out.println("Error: " + e.toString()); return false; } } } } ```

He started the test suite. While waiting, he stretched his arms above his head. His back ached from sitting too long. He got up and walked to the break room to refill his coffee cup. When he returned, the tests were still running.

Alex checked his phone. Three missed calls from his roommate, probably wondering if he was coming home tonight. He'd text him in the morning. Right now, fixing this bug was more important than sleep.

The test results finally appeared on the screen. All green. The application was running smoothly.

"Let's see how it handles the load now," he said, starting the performance testing tool.

```bash $ ./load-test.sh -t 300 -u 150 -r 10 http://localhost:8080/servicehub > Initializing test with 150 virtual users > Ramping up 10 users per second > Targeting http://localhost:8080/servicehub > Test running... ```

The tool simulated hundreds of users accessing ServiceHub simultaneously. In previous tests, the application crashed after reaching about fifty concurrent users. This time, the numbers kept climbing: 60, 70, 80...

No crashes.

Alex smiled as the counter passed 100 concurrent users without issues. He checked the output:

``` > Test completed successfully > Metrics summary: > - Peak users: 150 > - Avg response time: 230ms (previous: 384ms) > - 95th percentile: 412ms > - Errors: 0 > - Memory usage: stable at ~1.2GB ```

The performance metrics showed a 40% improvement in response time. This wasn't just a fix—it was a major optimization.

He compiled the patch, documented the changes, and composed an email to the release team:

``` Subject: Critical Fix for ServiceHub Memory Leak

Team,

I've identified and fixed the memory leak causing ServiceHub to crash under heavy load. The issue was in the authentication module—database connections weren't being properly closed after user sessions ended.

The fix has been tested with 100+ concurrent users (twice our previous limit) and shows a 40% performance improvement in response time.

Attached is the patch ready for deployment.

Given the critical nature of this issue and that we're losing Hartman account because of it, I recommend deploying this fix in tomorrow morning's emergency release.

- Alex ```

He attached the patch file and hit send. Then he shut down his computer, gathered his things, and headed out. The office was completely silent except for the sound of his footsteps.

Outside, the night air felt refreshing against his face. The streets were empty. He walked to his car in the parking garage, got in, and drove home in a daze. He was exhausted but satisfied. He'd found the needle in the haystack.

When he arrived home, he didn't even bother changing clothes. He collapsed onto his bed and was asleep within seconds.

---

Alex's alarm blared at 8:30 AM. He groaned and reached for his phone to silence it. He'd slept for barely five hours, but there was no way he was missing the fallout from his fix. He wanted to be there when they deployed it.

He showered quickly, put on fresh clothes, and grabbed a granola bar from the kitchen. His roommate, Ben, was already gone for the day. Alex noticed a note on the refrigerator: "Still alive?"

He smiled and headed out.

The morning traffic was heavy, but Alex didn't mind. He was replaying the fix in his head, making sure he hadn't missed anything. By the time he arrived at the office, it was almost 9:30 AM.

As he walked through the door, he noticed something unusual. People were looking at him. Not just looking—they were smiling, nodding, giving him thumbs up. Word had spread about his late-night heroics.

"There he is!" shouted Mei, one of the front-end developers. "The bug slayer returns!"

Alex grinned as he walked to his desk. Several team members gathered around him, patting him on the back and asking how he'd found the leak.

"Just lucky, I guess," he said, setting down his laptop bag.

"Lucky? You've been hunting that thing for weeks," said Raj, his project lead. "The release team deployed your fix at 6 AM. Early reports show the system is running better than ever."

"Great," Alex said, feeling a mix of pride and relief. "Any word from the Hartman account?"

"That's the best part," Raj replied with a broad smile. "They were about to jump ship, but when their CTO saw the performance improvements this morning, he called our sales team. They're staying with us, and they're considering expanding their contract."

"Seriously?" Alex couldn't believe it. Hartman was their biggest client, representing almost 20% of the company's revenue.

"Seriously. You saved us, man."

As Alex logged into his computer, people continued to stop by his desk to congratulate him. He tried to focus on checking his emails, but the stream of well-wishers made it difficult.

Then a hush fell over the open office. Alex looked up to see Caroline Weber, the CTO, walking toward his desk. Everyone pretended to get back to work while watching from the corners of their eyes.

Caroline stopped in front of Alex's desk. She was tall, imposing, and rarely visited the development floor. When she did, it usually meant something important—or something had gone terribly wrong.

"Alex," she said, extending her hand. "I wanted to personally thank you for your work last night."

Alex stood and shook her hand. "Just doing my job."

"You did more than that. The Hartman account is worth fifteen million dollars annually to us. Their CTO called me this morning to say they're staying, and they're impressed with how quickly we resolved their issue."

"That's great news," Alex said, feeling the eyes of his colleagues on him.

"It is. Which is why I wanted to invite you to our executive lunch today. The board is meeting to discuss the quarterly results, and I think they'd like to hear about your contribution."

Alex blinked in surprise. The executive lunch was legendary—a weekly gathering where the company's top brass discussed strategy over gourmet food in the private dining room. Regular employees were almost never invited.

"I'd be honored," he managed to say.

"Good. 12:30 in the executive dining room. And Alex—we appreciate team players who go above and beyond." With that, Caroline turned and walked back toward the elevators.

As soon as she was gone, the office erupted in excited whispers. Raj came over again, his eyes wide.

"Dude, do you know what this means? They only invite people to that lunch when they're being considered for promotion."

"Really?" Alex asked, trying to process everything. Just yesterday, he was another anonymous developer hunting down a bug. Today, he was having lunch with the executives.

"Trust me, I've been here eight years. The last person from our team who got invited was promoted to senior architect two weeks later."

Alex sat back in his chair, a mix of excitement and nervousness washing over him. A promotion would mean more money, more responsibility—and recognition for all the late nights and weekends he'd put into this job.

The morning passed in a blur. Alex tried to focus on his regular tasks, but his mind kept drifting to the executive lunch. He changed his status on the team's messaging app to "Do Not Disturb" and attempted to catch up on other project work.

Around 11:45 AM, he decided to prepare for the lunch. He went to the restroom to wash his face and make sure he looked presentable. Thankfully, he'd worn a decent button-up shirt today instead of his usual t-shirt.

As he was about to leave the restroom, his phone buzzed. It was a message from Travis in customer support:

"Hey Alex, are you the one who fixed the memory leak last night?"

He quickly typed back: "Yes, is everything okay with the deployment?"

Three dots appeared as Travis typed his response. Then:

"We're getting some strange reports from users. Can you swing by the support floor?"

Alex frowned. That didn't sound good. He checked the time—he still had about thirty minutes before the executive lunch.

"On my way," he replied.

The customer support department was on the second floor, a noisy space with dozens of support agents wearing headsets and talking to customers. Alex spotted Travis at his desk and walked over.

"What's going on?" he asked.

Travis looked stressed. He pointed to his screen, which showed the support ticket queue. "We started getting calls about twenty minutes ago. Users reporting weird errors after the update."

"What kind of errors?"

"All kinds. Some say they can't access their reports. Others are getting error messages when they try to create new projects. A few are saying the entire dashboard looks wrong—missing buttons, data not displaying correctly."

Alex felt a knot forming in his stomach. "How many users are affected?"

Travis scrolled through the ticket list. "So far, about thirty have called in. But that's just the ones who bothered to contact support. Could be more."

"Let me see one of the error reports," Alex said, leaning over Travis's shoulder.

Travis opened a ticket with attached screenshots. The errors didn't make any sense. One showed a dashboard with misaligned elements. Another showed an error message about an invalid data format. None of these issues should have anything to do with the memory leak fix.

"This doesn't make sense," Alex muttered. "The fix I implemented was isolated to the authentication module. It shouldn't affect any of these systems."

"Well, something's definitely broken," Travis said. "And it started right after the update was deployed."

Alex checked the time again. 12:10 PM. He was supposed to be at the executive lunch in twenty minutes.

"I need to see this firsthand," he said. "Can you let me use your test account?"

Travis nodded and logged into a test environment. Alex tried navigating to the reports section, and sure enough, an error message appeared: "Invalid data format. Please contact your system administrator."

He tried another section. It loaded, but the layout was completely wrong, with buttons overlapping and text cut off. This was a disaster.

Alex's phone buzzed again. It was Raj:

"Where are you? The support team says there are issues with the deployment. We need to meet ASAP."

Just as he read the message, another one came in from Mei:

"Emergency meeting in Conference Room B now. Something's wrong with the production system."

Alex looked at the time again. 12:15 PM. The executive lunch was in fifteen minutes, but there was no way he could go now. Not with the system falling apart.

"Travis, I have to go. Keep logging those tickets—we need to understand how widespread this is."

He rushed to Conference Room B, where several members of the development team were already gathered. Raj stood at the front of the room, his face grim.

"Alex, what did you change last night?" he asked as soon as Alex entered.

"Just what I documented in the email. I fixed the connection pool in the authentication module to properly close database connections."

Mei spoke up from her seat. "That shouldn't affect the UI or the reporting module."

"I know," Alex said, feeling defensive. "I ran all the tests before submitting the patch. Everything passed."

"Well, something's broken," Raj said. "We're getting reports from all over. The system is technically up—no crashes—but users are reporting dozens of different issues."

Alex sat down heavily in an empty chair. "I don't understand. The fix was clean and isolated."

"Nothing is isolated in our system," said Omar, one of the senior developers. "Remember, ServiceHub was built through three different acquisitions. The codebase is a patchwork of different technologies."

"But still," Alex protested, "how could fixing a connection pool break the UI and reporting functions?"

Raj pulled up a system diagram on the projector. "We need to trace the dependencies. The authentication module connects to what else?"

As they began mapping out the system connections, Alex's phone buzzed again. It was a message from Caroline's assistant:

"Mr. Mercer, Ms. Weber is wondering if you'll be joining the executive lunch? They're seated now."

Alex stared at the message, his heart sinking. He typed back:

"Please apologize to Ms. Weber for me. There are critical issues with the system that require immediate attention. I need to help resolve them."

He put his phone down and focused on the problem at hand. The room was filled with the sound of typing as developers checked logs and tested different parts of the system.

"I think I found something," Mei said after a few minutes. "The authentication module is calling a shared library that's also used by the UI components."

"Let me see," Alex said, moving to look at her screen.

Mei pointed to a line of code:

```java public static Object getConnection(String userId) { return DatabaseManager.getConnectionForUser(userId); }

public static Object getConnection(String userId, boolean isSecure) { return new ManagedConnection(DatabaseManager.getConnectionForUser(userId)); } ```

"When you fixed the connection pool, you updated this method signature. But it looks like the UI components are still calling the old version with different parameters."

Alex looked closer at the UI code:

```java Object dbConn = SharedLibrary.getConnection(currentUser.getId()); ```

She was right. The method signature had changed slightly with his fix, causing it to return different results when called from other parts of the system.

"That explains the UI issues," he said, "but what about the reporting errors?"

Omar raised his hand. "I think I have that one. Look at this reporting module code:"

```java public class ReportGenerator { public static List generateReport(String reportType, Date startDate, Date endDate) { try { Connection[] availableConnections = AuthenticationService.connectionPool.getAvailableConnections(); if (availableConnections.length > 0 && availableConnections[0].getClass().getName().equals("java.sql.Connection")) { Connection conn = availableConnections[0]; } else { throw new RuntimeException("Cannot generate report: no connections available"); } } catch (Exception e) { return new ArrayList<>(); } } } ```

"The reporting module directly queries the connection pool you modified. It's accessing the internals and expects connections to be raw java.sql.Connection objects. When you changed that behavior to use ManagedConnection wrappers..."

"It broke the queries," Alex finished, running his hand through his hair. "But why didn't the tests catch this?"

"Our test suite doesn't cover cross-module integration thoroughly enough," Raj said. "We've been meaning to improve that for months."

Alex's phone buzzed again with more messages. Customer support reporting additional issues. His teammates asking for updates. And one from Caroline:

"Alex, I understand you're handling an emergency. Keep me posted on the situation."

The knot in his stomach tightened. His moment of triumph had turned into a nightmare. One fix had apparently broken dozens of features across the system.

"Okay," Raj said, taking charge. "We need to identify all affected systems and prioritize fixes. Alex, since you made the original change, you'll coordinate the response. Mei, focus on the UI issues. Omar, tackle the reporting module."

As Raj continued assigning tasks, Alex's phone started ringing. It was the customer support manager. He excused himself and stepped into the hallway to answer.

"Alex, we're getting flooded with calls," the manager said without preamble. "What's going on?"

"We're working on it," Alex replied, trying to sound calmer than he felt. "It appears my fix affected several interconnected systems. We're mapping the issues now."

"Well, work faster. The Hartman account just called. They're seeing errors throughout their instance. Their CTO is furious."

Alex closed his eyes. The very account he'd supposedly saved this morning was now in jeopardy again—because of him.

"Tell them we're on it. We'll have a fix as soon as possible."

He ended the call and returned to the conference room, where the team was now gathered around a whiteboard. Raj had drawn a complex diagram showing the relationships between different modules.

"We've identified ten distinct issues so far," Raj announced as Alex took his seat. "Each one will need its own fix."

Ten issues. From one fix. The irony wasn't lost on Alex.

"How long will it take to fix them all?" he asked.

Raj looked grim. "Best case? Several hours. Worst case? We might need to roll back your fix entirely and start over."

"We can't roll back," Alex said. "That would reintroduce the original memory leak. Hartman would leave for sure."

"They might leave anyway if their system is unusable," Mei pointed out.

Alex's phone buzzed again. More messages pouring in. More reports of issues. More pressure.

He looked around at his team, now mobilizing to fix his mistake. The celebration from earlier seemed like it happened days ago, not hours. His moment in the spotlight, his potential promotion—all of it was slipping away as quickly as it had come.

As the team broke into smaller groups to tackle different issues, Alex stared at the error reports piling up on his screen. One fix, ten problems. He'd never felt more like a software developer than at this moment.

His phone buzzed once more. It was a message from Caroline:

"Update needed. How bad is it?"

Note: This code is intentionally simplified and contains several bad practices (SQL injection, hard-coded credentials, thread safety issues). It’s written this way to highlight the bug in the story. A real implementation would use a connection pool, prepared statements, and secure credential management.