<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Akif Keklik</title>
    <description>The latest articles on DEV Community by Akif Keklik (@akifkeklik).</description>
    <link>https://dev.to/akifkeklik</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4250599%2F65fb64ea-6ba5-4138-97a1-471295ce205a.png</url>
      <title>DEV Community: Akif Keklik</title>
      <link>https://dev.to/akifkeklik</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/akifkeklik"/>
    <language>en</language>
    <item>
      <title>AI Can Write Code. But Who Is Responsible for Its Quality?</title>
      <dc:creator>Akif Keklik</dc:creator>
      <pubDate>Tue, 17 Nov 2026 21:56:10 +0000</pubDate>
      <link>https://dev.to/akifkeklik/ai-can-write-code-but-who-is-responsible-for-its-quality-a2n</link>
      <guid>https://dev.to/akifkeklik/ai-can-write-code-but-who-is-responsible-for-its-quality-a2n</guid>
      <description>&lt;h1&gt;
  
  
  AI Can Write Code. But Who Is Responsible for Its Quality?
&lt;/h1&gt;

&lt;p&gt;&lt;em&gt;How automated testing, code review, and CI/CD help us build reliable software with AI coding agents.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;AI coding agents are no longer just suggesting code.&lt;/p&gt;

&lt;p&gt;Some can analyze tasks, inspect repositories, modify multiple files, run tests, and prepare pull requests.&lt;/p&gt;

&lt;p&gt;This changes how software is developed.&lt;/p&gt;

&lt;p&gt;But it also brings an important question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;If AI writes a significant part of our code, who is responsible for its quality?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The real challenge is not whether AI can generate code.&lt;/p&gt;

&lt;p&gt;It is whether that code actually solves the intended problem, remains secure, and can be maintained in the future.&lt;/p&gt;

&lt;p&gt;Let's look at how we can approach this.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F97iiggghoifehrh8lo3x.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F97iiggghoifehrh8lo3x.jpg" alt=" " width="800" height="447"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Working Code Does Not Always Mean Correct Code
&lt;/h2&gt;

&lt;p&gt;One of the most dangerous assumptions in software development is believing that code is correct simply because it runs.&lt;/p&gt;

&lt;p&gt;Imagine an e-commerce application with an order creation service.&lt;/p&gt;

&lt;p&gt;We ask an AI coding agent to implement the following operations:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Create an order.&lt;/li&gt;
&lt;li&gt;Decrease the available stock.&lt;/li&gt;
&lt;li&gt;Update the payment status.&lt;/li&gt;
&lt;li&gt;Save the order in the database.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The generated code might compile and even pass the existing tests.&lt;/p&gt;

&lt;p&gt;But several important questions remain:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What happens if two users purchase the last item simultaneously?&lt;/li&gt;
&lt;li&gt;What happens if payment succeeds but the order cannot be saved?&lt;/li&gt;
&lt;li&gt;Can the customer be charged twice if the same payment request is sent again?&lt;/li&gt;
&lt;li&gt;If the database fails halfway through the operation, is the stock restored?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These are not problems that can be solved simply by generating code.&lt;/p&gt;

&lt;p&gt;They require an understanding of business rules, system architecture, and possible failure scenarios.&lt;/p&gt;

&lt;p&gt;A program running successfully does not prove that it satisfies every requirement.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Why Should AI-Generated Code Be Reviewed?
&lt;/h2&gt;

&lt;p&gt;Large language models generate code based on patterns learned from their training data.&lt;/p&gt;

&lt;p&gt;However, a reasonable-looking solution is not necessarily compatible with the requirements of an existing project.&lt;/p&gt;

&lt;p&gt;There are three common risks.&lt;/p&gt;

&lt;h3&gt;
  
  
  Misunderstanding the Context
&lt;/h3&gt;

&lt;p&gt;AI might generate a correct function but misunderstand existing business rules or relationships between services.&lt;/p&gt;

&lt;h3&gt;
  
  
  Missing Edge Cases
&lt;/h3&gt;

&lt;p&gt;The generated code may work under normal conditions but fail when it encounters:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Empty data.&lt;/li&gt;
&lt;li&gt;Unauthorized access.&lt;/li&gt;
&lt;li&gt;Concurrent requests.&lt;/li&gt;
&lt;li&gt;Unexpected exceptions.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  False Confidence
&lt;/h3&gt;

&lt;p&gt;Code can look clean, well-documented, and professional.&lt;/p&gt;

&lt;p&gt;But readability is not the same as correctness.&lt;/p&gt;

&lt;p&gt;This is why AI-generated code should not be treated as automatically trustworthy.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. How Do Professional Teams Verify Code Quality?
&lt;/h2&gt;

&lt;p&gt;Whether we use AI or not, reliable software requires multiple layers of verification.&lt;/p&gt;

&lt;p&gt;These layers serve different purposes.&lt;/p&gt;

&lt;h3&gt;
  
  
  A. Static Analysis: Inspecting Code Without Running It
&lt;/h3&gt;

&lt;p&gt;Static analysis examines source code without executing it.&lt;/p&gt;

&lt;p&gt;It can help identify:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Unused variables.&lt;/li&gt;
&lt;li&gt;Suspicious code structures.&lt;/li&gt;
&lt;li&gt;Potential null reference problems.&lt;/li&gt;
&lt;li&gt;Coding standard violations.&lt;/li&gt;
&lt;li&gt;Certain security risks.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In Java projects, tools such as SonarQube, Checkstyle, and SpotBugs can be useful.&lt;/p&gt;

&lt;p&gt;However, static analysis cannot prove that business logic is correct.&lt;/p&gt;

&lt;p&gt;It identifies certain classes of problems, not every possible defect.&lt;/p&gt;

&lt;h3&gt;
  
  
  B. Automated Testing: Verifying Behavior
&lt;/h3&gt;

&lt;p&gt;Automated tests check whether software produces the expected results under defined conditions.&lt;/p&gt;

&lt;p&gt;Three important test types are:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Unit Tests&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;These test a small and isolated part of the application.&lt;/p&gt;

&lt;p&gt;For example, we can verify whether an order total is calculated correctly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Integration Tests&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;These verify whether multiple components work together.&lt;/p&gt;

&lt;p&gt;In a Spring Boot application, we might test the interaction between services, repositories, and a real test database.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;End-to-End Tests&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;These verify a complete user workflow.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;A user logs in.&lt;/li&gt;
&lt;li&gt;Selects a product.&lt;/li&gt;
&lt;li&gt;Creates an order.&lt;/li&gt;
&lt;li&gt;Receives the expected result.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;But there is an important detail:&lt;/p&gt;

&lt;p&gt;A passing test does not automatically mean that the test suite is comprehensive.&lt;/p&gt;

&lt;p&gt;A poorly designed test can even pass when the actual implementation is wrong.&lt;/p&gt;

&lt;h3&gt;
  
  
  C. Code Review: Understanding the Change
&lt;/h3&gt;

&lt;p&gt;Code review is the process of examining changes made by another developer.&lt;/p&gt;

&lt;p&gt;It remains important when AI is involved.&lt;/p&gt;

&lt;p&gt;When reviewing a pull request, we should ask:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Does this change actually solve the requested problem?&lt;/li&gt;
&lt;li&gt;Is it consistent with the existing architecture?&lt;/li&gt;
&lt;li&gt;Does it introduce security risks?&lt;/li&gt;
&lt;li&gt;Does it add unnecessary complexity?&lt;/li&gt;
&lt;li&gt;Could it break existing business rules?&lt;/li&gt;
&lt;li&gt;Does it introduce new failure scenarios?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;AI can help with initial reviews, identify suspicious code, and save developers time.&lt;/p&gt;

&lt;p&gt;However, automatically accepting every AI-generated review comment is another mistake.&lt;/p&gt;

&lt;p&gt;Human judgment is particularly important when evaluating business rules and architectural decisions.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. CI/CD: Making Quality Checks Part of Development
&lt;/h2&gt;

&lt;p&gt;Quality checks should not depend entirely on manual reviews after implementation.&lt;/p&gt;

&lt;p&gt;Modern software teams integrate these checks into CI/CD pipelines.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Continuous Integration (CI)&lt;/strong&gt; helps developers integrate code changes regularly and verify them through automated checks.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Continuous Delivery/Deployment (CD)&lt;/strong&gt; prepares software for release or automatically deploys it under appropriate conditions.&lt;/p&gt;

&lt;p&gt;For example, when a developer opens a pull request on GitHub, we can automatically:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Build the project.&lt;/li&gt;
&lt;li&gt;Run unit and integration tests.&lt;/li&gt;
&lt;li&gt;Perform static analysis.&lt;/li&gt;
&lt;li&gt;Scan dependencies for known vulnerabilities.&lt;/li&gt;
&lt;li&gt;Report failed checks.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Tools such as GitHub Actions make this process possible.&lt;/p&gt;

&lt;p&gt;This means AI-generated code must pass the same quality gates as code written manually.&lt;/p&gt;

&lt;p&gt;The important point is not whether AI generated the code.&lt;/p&gt;

&lt;p&gt;It is whether that code meets the project's quality requirements before being merged.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Human-in-the-Loop: Why Human Oversight Still Matters
&lt;/h2&gt;

&lt;p&gt;As AI agents become more capable, a new development approach is becoming increasingly relevant: Human-in-the-Loop.&lt;/p&gt;

&lt;p&gt;In this approach, AI can perform certain tasks independently, while humans remain involved at important decision points.&lt;/p&gt;

&lt;p&gt;Imagine giving an AI agent the following task:&lt;/p&gt;

&lt;p&gt;"Find the authorization issue in the product deletion endpoint, implement a fix, add tests, and prepare a pull request."&lt;/p&gt;

&lt;p&gt;The agent might:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Inspect the repository.&lt;/li&gt;
&lt;li&gt;Identify the relevant files.&lt;/li&gt;
&lt;li&gt;Modify the implementation.&lt;/li&gt;
&lt;li&gt;Add tests.&lt;/li&gt;
&lt;li&gt;Run the test suite.&lt;/li&gt;
&lt;li&gt;Prepare a pull request.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But someone still needs to evaluate the result.&lt;/p&gt;

&lt;p&gt;Does the change actually fix the authorization problem?&lt;/p&gt;

&lt;p&gt;Does it break the existing security architecture?&lt;/p&gt;

&lt;p&gt;Is it safe to deploy?&lt;/p&gt;

&lt;p&gt;The developer's role does not disappear.&lt;/p&gt;

&lt;p&gt;Instead, developers increasingly need to evaluate the correctness, risks, and system-wide impact of generated solutions.&lt;/p&gt;

&lt;p&gt;AI can take over more implementation work, but that does not automatically make the entire software lifecycle reliable.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. A Practical Checklist for Developers
&lt;/h2&gt;

&lt;p&gt;Before merging a feature developed with AI assistance, consider the following questions.&lt;/p&gt;

&lt;h3&gt;
  
  
  Code Correctness
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Does the implementation satisfy the requirements?&lt;/li&gt;
&lt;li&gt;Have edge cases been considered?&lt;/li&gt;
&lt;li&gt;Are existing business rules preserved?&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Testing and Quality
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Are relevant unit tests included?&lt;/li&gt;
&lt;li&gt;Are integration tests necessary?&lt;/li&gt;
&lt;li&gt;Do the tests verify meaningful scenarios?&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Security
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Are authorization checks implemented correctly?&lt;/li&gt;
&lt;li&gt;Have sensitive values accidentally entered logs or source control?&lt;/li&gt;
&lt;li&gt;Do dependencies contain known vulnerabilities?&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Architecture and Maintainability
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Does the implementation fit the existing architecture?&lt;/li&gt;
&lt;li&gt;Has unnecessary complexity been introduced?&lt;/li&gt;
&lt;li&gt;Can another developer understand and maintain the code?&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Final Verification
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Have CI/CD checks passed?&lt;/li&gt;
&lt;li&gt;Has the pull request been reviewed?&lt;/li&gt;
&lt;li&gt;Has the implementation been verified in the appropriate environment?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This checklist cannot eliminate every risk.&lt;/p&gt;

&lt;p&gt;But it provides a practical starting point for preventing unverified AI-generated code from entering a project.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion: The Future Developer Must Be Able to Verify Code, Not Just Generate It
&lt;/h2&gt;

&lt;p&gt;AI is making software development faster.&lt;/p&gt;

&lt;p&gt;Tasks that previously took hours can sometimes be completed in much less time.&lt;/p&gt;

&lt;p&gt;But speed and quality are not the same thing.&lt;/p&gt;

&lt;p&gt;An AI agent generating thousands of lines of code does not prove that the implementation follows the correct architecture, is secure, or satisfies real user requirements.&lt;/p&gt;

&lt;p&gt;The important skills are still understanding requirements, knowing how systems work, evaluating risks, and verifying the final result.&lt;/p&gt;

&lt;p&gt;AI can generate code.&lt;/p&gt;

&lt;p&gt;But evaluating what that code actually does, what risks it introduces, and whether it is ready for production remains a serious engineering responsibility.&lt;/p&gt;

&lt;p&gt;Perhaps one of the most important skills that will distinguish developers in the coming years will not be how much code they can generate.&lt;/p&gt;

&lt;p&gt;It will be how well they can evaluate the quality of the code they produce.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What do you think? Will code review become even more important as AI agents take on more development tasks?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I'd love to hear your perspective.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Further reading: &lt;a href="https://docs.github.com/en/actions" rel="noopener noreferrer"&gt;GitHub Actions Documentation&lt;/a&gt; · &lt;a href="https://owasp.org/www-project-application-security-verification-standard/" rel="noopener noreferrer"&gt;OWASP Application Security Verification Standard&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>softwareengineering</category>
      <category>testing</category>
      <category>codereview</category>
    </item>
    <item>
      <title>How Do Engineers Find Out Why an Application Is Slow?</title>
      <dc:creator>Akif Keklik</dc:creator>
      <pubDate>Tue, 17 Nov 2026 21:51:15 +0000</pubDate>
      <link>https://dev.to/akifkeklik/how-do-engineers-find-out-why-an-application-is-slow-1kko</link>
      <guid>https://dev.to/akifkeklik/how-do-engineers-find-out-why-an-application-is-slow-1kko</guid>
      <description>&lt;p&gt;&lt;em&gt;Performance is not about guessing. It is about measuring, finding bottlenecks, and proving that an improvement actually works.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Imagine opening a web application.&lt;/p&gt;

&lt;p&gt;The homepage takes several seconds to load. You click a button, but nothing happens immediately. Sometimes, loading a simple list takes much longer than expected.&lt;/p&gt;

&lt;p&gt;The first solutions that come to mind are usually familiar:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Get a more powerful server.&lt;/li&gt;
&lt;li&gt;Add caching.&lt;/li&gt;
&lt;li&gt;Optimize the code.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But an experienced engineer does not necessarily start with any of these.&lt;/p&gt;

&lt;p&gt;Instead, they ask:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where exactly is the system slow, and what evidence do we have?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Performance engineering is not simply noticing that an application feels slow. It means measuring the problem, identifying its source, applying the right solution, and verifying the result.&lt;/p&gt;

&lt;p&gt;Let's break this down.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fs8tqkyj0wsaevubw17cc.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fs8tqkyj0wsaevubw17cc.jpg" alt=" " width="799" height="436"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  1. First, Make "Slow" Measurable
&lt;/h2&gt;

&lt;p&gt;When a user says an application is slow, that feedback matters.&lt;/p&gt;

&lt;p&gt;But technically, it is not enough.&lt;/p&gt;

&lt;p&gt;Slowness can appear in different ways:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A page takes too long to load.&lt;/li&gt;
&lt;li&gt;An API endpoint responds slowly.&lt;/li&gt;
&lt;li&gt;A database query takes too much time.&lt;/li&gt;
&lt;li&gt;The interface does not respond quickly to user interactions.&lt;/li&gt;
&lt;li&gt;The application loses performance under heavy traffic.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Each problem requires a different investigation.&lt;/p&gt;

&lt;p&gt;For example, imagine that a product listing page loads slowly.&lt;/p&gt;

&lt;p&gt;The problem could be:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Large images.&lt;/li&gt;
&lt;li&gt;Unnecessary frontend operations.&lt;/li&gt;
&lt;li&gt;A slow API response.&lt;/li&gt;
&lt;li&gt;An inefficient database query.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The first step is to identify where time is actually being spent.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Four Metrics Engineers Should Understand
&lt;/h2&gt;

&lt;p&gt;One useful model is Google's Four Golden Signals, described in its Site Reliability Engineering practices.&lt;/p&gt;

&lt;p&gt;It focuses on four important aspects of system health.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Latency
&lt;/h3&gt;

&lt;p&gt;How long does a request take to complete?&lt;/p&gt;

&lt;p&gt;For example, an endpoint such as:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;GET /api/products&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;might respond in 150 milliseconds for one request and 2 seconds for another.&lt;/p&gt;

&lt;p&gt;Looking only at average response time can hide serious problems.&lt;/p&gt;

&lt;p&gt;This is why percentiles matter:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;P50:&lt;/strong&gt; 50% of requests complete within this time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;P95:&lt;/strong&gt; 95% of requests complete within this time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;P99:&lt;/strong&gt; 99% of requests complete within this time.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Imagine that P50 is 120 ms, but P95 is 1.8 seconds.&lt;/p&gt;

&lt;p&gt;Most users receive a fast response, but a significant portion may still experience noticeable delays.&lt;/p&gt;

&lt;p&gt;P95 and P99 help reveal problems that averages can hide.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Traffic
&lt;/h3&gt;

&lt;p&gt;How much load is the system receiving?&lt;/p&gt;

&lt;p&gt;For a web application, requests per second are an important measurement.&lt;/p&gt;

&lt;p&gt;An application might normally receive 20 requests per second but suddenly receive 500 during a campaign.&lt;/p&gt;

&lt;p&gt;We need to understand how the system behaves as traffic increases.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Errors
&lt;/h3&gt;

&lt;p&gt;How many requests are failing?&lt;/p&gt;

&lt;p&gt;HTTP status codes such as 500, 502, and 503 can indicate server-side problems.&lt;/p&gt;

&lt;p&gt;However, status codes alone do not tell the whole story.&lt;/p&gt;

&lt;p&gt;An API might return &lt;code&gt;200 OK&lt;/code&gt; while still providing incorrect or incomplete business data.&lt;/p&gt;

&lt;p&gt;Error rates should be considered alongside application behavior.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Saturation
&lt;/h3&gt;

&lt;p&gt;How much of the system's available resources are being used?&lt;/p&gt;

&lt;p&gt;Important measurements include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;CPU usage.&lt;/li&gt;
&lt;li&gt;Memory usage.&lt;/li&gt;
&lt;li&gt;Disk utilization.&lt;/li&gt;
&lt;li&gt;Database connection pools.&lt;/li&gt;
&lt;li&gt;Thread pools.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For example, when a database connection pool runs out of available connections, new requests may have to wait.&lt;/p&gt;

&lt;p&gt;Performance can deteriorate even before CPU usage reaches 100%.&lt;/p&gt;

&lt;p&gt;Together, these four signals help us understand not only whether a system is slow, but also why.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. How Do We Find the Bottleneck?
&lt;/h2&gt;

&lt;p&gt;A good starting point is to divide the application into layers.&lt;/p&gt;

&lt;p&gt;Consider this simplified request flow:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;User → Frontend → API → Backend → Database&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;A delay at any stage can affect the entire user experience.&lt;/p&gt;

&lt;h3&gt;
  
  
  Frontend: Chrome DevTools
&lt;/h3&gt;

&lt;p&gt;The Network tab in Chrome DevTools is a practical starting point.&lt;/p&gt;

&lt;p&gt;It helps us inspect:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;When a request starts.&lt;/li&gt;
&lt;li&gt;How long it takes.&lt;/li&gt;
&lt;li&gt;When the first response arrives.&lt;/li&gt;
&lt;li&gt;How long the response data takes to download.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Imagine an API request that takes 2 seconds.&lt;/p&gt;

&lt;p&gt;If 1.7 seconds are spent waiting for the server's first response, the problem probably requires investigation on the backend side.&lt;/p&gt;

&lt;h3&gt;
  
  
  Backend: Endpoint Response Times
&lt;/h3&gt;

&lt;p&gt;On the backend, we need to measure how long individual endpoints take to respond.&lt;/p&gt;

&lt;p&gt;In Java and Spring Boot applications, Spring Boot Actuator and Micrometer can help.&lt;/p&gt;

&lt;p&gt;Micrometer collects application metrics. These metrics can be exported to systems such as Prometheus and visualized with Grafana.&lt;/p&gt;

&lt;p&gt;For example, we can investigate:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which endpoint is the slowest?&lt;/li&gt;
&lt;li&gt;How does response time change as traffic increases?&lt;/li&gt;
&lt;li&gt;Is the error rate increasing?&lt;/li&gt;
&lt;li&gt;How much memory is the JVM using?&lt;/li&gt;
&lt;li&gt;Is garbage collection affecting application performance?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These measurements allow us to make decisions based on evidence rather than assumptions.&lt;/p&gt;

&lt;h3&gt;
  
  
  Database: Are Queries Efficient?
&lt;/h3&gt;

&lt;p&gt;Sometimes backend code looks perfectly clean while the database is causing serious performance problems.&lt;/p&gt;

&lt;p&gt;Consider a product listing that loads 100 products.&lt;/p&gt;

&lt;p&gt;If the application executes an additional database query for each product, we may end up with 101 queries.&lt;/p&gt;

&lt;p&gt;This is an example of the N+1 Query Problem, which can occur in Hibernate-based applications.&lt;/p&gt;

&lt;p&gt;We should inspect:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;SQL queries.&lt;/li&gt;
&lt;li&gt;Database indexes.&lt;/li&gt;
&lt;li&gt;Query execution plans.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Tools such as &lt;code&gt;EXPLAIN&lt;/code&gt; help us understand how the database executes a query.&lt;/p&gt;

&lt;p&gt;The goal is not to add indexes randomly. It is to identify the queries that are actually expensive.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Is Being Fast in Development Enough?
&lt;/h2&gt;

&lt;p&gt;No.&lt;/p&gt;

&lt;p&gt;An application running quickly on a developer's computer does not guarantee the same performance under real user traffic.&lt;/p&gt;

&lt;p&gt;Production environments have:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Multiple concurrent users.&lt;/li&gt;
&lt;li&gt;Different network conditions.&lt;/li&gt;
&lt;li&gt;Larger datasets.&lt;/li&gt;
&lt;li&gt;Changing traffic patterns.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is where load testing becomes useful.&lt;/p&gt;

&lt;p&gt;For example, we can test an e-commerce application with:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;50 concurrent users.&lt;/li&gt;
&lt;li&gt;100 concurrent users.&lt;/li&gt;
&lt;li&gt;500 concurrent users.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;We should not only check whether the application stays online.&lt;/p&gt;

&lt;p&gt;We should also measure response times, error rates, and resource consumption.&lt;/p&gt;

&lt;p&gt;Common tools include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;k6&lt;/li&gt;
&lt;li&gt;Apache JMeter&lt;/li&gt;
&lt;li&gt;Gatling&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;There are also different types of performance tests:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Load Testing:&lt;/strong&gt; Measures behavior under expected workloads.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stress Testing:&lt;/strong&gt; Pushes the system beyond its expected capacity to identify its limits.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Spike Testing:&lt;/strong&gt; Examines how the system reacts to sudden increases in traffic.&lt;/p&gt;

&lt;p&gt;These tests help us understand how an application behaves under different conditions.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. User Experience Is Also Performance
&lt;/h2&gt;

&lt;p&gt;Backend response time is not the whole story.&lt;/p&gt;

&lt;p&gt;An API might respond quickly, but if the user sees a blank screen while the page loads, the overall experience is still poor.&lt;/p&gt;

&lt;p&gt;Google's Core Web Vitals provide useful metrics for evaluating web performance from the user's perspective.&lt;/p&gt;

&lt;p&gt;Three important metrics are:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;LCP (Largest Contentful Paint):&lt;/strong&gt; Measures how long it takes for the main page content to become visible. A good target is 2.5 seconds or less.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;INP (Interaction to Next Paint):&lt;/strong&gt; Measures how quickly the interface responds to user interactions. A good target is 200 ms or less.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CLS (Cumulative Layout Shift):&lt;/strong&gt; Measures unexpected layout movement while the page loads. A good target is 0.1 or less.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These thresholds are evaluated at the 75th percentile of real-user data.&lt;/p&gt;

&lt;p&gt;This is why testing only on our own computers is not enough. We also need to understand the experience of real users.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Where Should an Engineer Start Optimizing?
&lt;/h2&gt;

&lt;p&gt;There is one important engineering principle:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Don't optimize before measuring.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Adding Redis because an endpoint feels slow, rewriting queries, or switching to microservices may introduce unnecessary complexity.&lt;/p&gt;

&lt;p&gt;A better approach is:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Measure the current P95 response time of the endpoint.&lt;/li&gt;
&lt;li&gt;Inspect database query execution times.&lt;/li&gt;
&lt;li&gt;Identify unnecessary queries or missing indexes.&lt;/li&gt;
&lt;li&gt;Apply a targeted improvement.&lt;/li&gt;
&lt;li&gt;Run the same test again.&lt;/li&gt;
&lt;li&gt;Compare the results.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;If response time decreases without increasing the error rate, we have measurable evidence that the change helped.&lt;/p&gt;

&lt;p&gt;Tools such as OpenTelemetry also become useful here.&lt;/p&gt;

&lt;p&gt;Distributed tracing allows us to follow a request as it moves through different parts of an application.&lt;/p&gt;

&lt;p&gt;This makes it easier to identify where delays occur, especially in systems with multiple services.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion: Performance Is a Measurement Problem
&lt;/h2&gt;

&lt;p&gt;What separates an experienced engineer is not simply knowing more technologies.&lt;/p&gt;

&lt;p&gt;It is the ability to approach problems systematically.&lt;/p&gt;

&lt;p&gt;When an application becomes slow, a good engineer does not immediately increase server capacity or introduce another technology.&lt;/p&gt;

&lt;p&gt;They investigate the data, identify the bottleneck, form a hypothesis, measure the result, and verify the improvement.&lt;/p&gt;

&lt;p&gt;Good engineering is not only about building a system that works.&lt;/p&gt;

&lt;p&gt;It is also about understanding how that system behaves under real conditions and improving it based on evidence.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A fast system is not necessarily the one with the most technologies. It is the one whose bottlenecks are understood and addressed correctly.&lt;/strong&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Further reading: &lt;a href="https://sre.google/sre-book/monitoring-distributed-systems/" rel="noopener noreferrer"&gt;Google SRE – Monitoring Distributed Systems&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>performance</category>
      <category>backend</category>
      <category>webdev</category>
      <category>observability</category>
    </item>
    <item>
      <title>The Code Didn't Change. So Why Did the Application Go Down?</title>
      <dc:creator>Akif Keklik</dc:creator>
      <pubDate>Tue, 17 Nov 2026 21:41:34 +0000</pubDate>
      <link>https://dev.to/akifkeklik/the-code-didnt-change-so-why-did-the-application-go-down-20km</link>
      <guid>https://dev.to/akifkeklik/the-code-didnt-change-so-why-did-the-application-go-down-20km</guid>
      <description>&lt;p&gt;What a hospital appointment system taught me about production failures, database availability, security, and testing.&lt;/p&gt;

&lt;p&gt;A few months ago, I deployed a hospital appointment system as part of my portfolio.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F73ig1hoku16vkwtqu9kr.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F73ig1hoku16vkwtqu9kr.jpg" alt=" " width="800" height="343"&gt;&lt;/a&gt;&lt;br&gt;
Everything seemed fine.&lt;/p&gt;

&lt;p&gt;Patients could book appointments, doctors could manage their schedules, and administrators could manage the system.&lt;/p&gt;

&lt;p&gt;Then, one day, I noticed something unexpected.&lt;/p&gt;

&lt;p&gt;The application had been down for around ten days.&lt;/p&gt;

&lt;p&gt;I hadn't made any changes that should have broken it. So what happened?&lt;/p&gt;

&lt;p&gt;That question led me to investigate something every software developer should understand:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A production system is more than its source code.&lt;/strong&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  1. First, What Did I Build?
&lt;/h2&gt;

&lt;p&gt;The project was a hospital appointment management system with three main roles:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Patients could book appointments.&lt;/li&gt;
&lt;li&gt;Doctors could manage appointments and medical records.&lt;/li&gt;
&lt;li&gt;Administrators could manage doctors, departments, and applications.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The backend was built as a modular monolith.&lt;/p&gt;

&lt;p&gt;In simple terms, it was a single deployable application divided into separate modules based on business responsibilities.&lt;/p&gt;

&lt;p&gt;For example, appointment, patient, and doctor operations had their own responsibilities.&lt;/p&gt;

&lt;p&gt;I chose this approach instead of introducing microservices because the project did not require the additional operational complexity.&lt;/p&gt;
&lt;h2&gt;
  
  
  2. Security Was Not Just About Login
&lt;/h2&gt;

&lt;p&gt;A hospital system handles sensitive personal information.&lt;/p&gt;

&lt;p&gt;That makes security an important part of its design.&lt;/p&gt;

&lt;p&gt;Here are some of the decisions I made.&lt;/p&gt;
&lt;h3&gt;
  
  
  Password Storage
&lt;/h3&gt;

&lt;p&gt;Passwords were not stored as plain text.&lt;/p&gt;

&lt;p&gt;I used BCrypt hashing to make password verification more resistant to brute-force attacks.&lt;/p&gt;

&lt;p&gt;I also made password reset responses consistent whether an account existed or not. This helps prevent account enumeration.&lt;/p&gt;
&lt;h3&gt;
  
  
  Protecting the Login Endpoint
&lt;/h3&gt;

&lt;p&gt;Login endpoints can be targeted by automated password-guessing attacks.&lt;/p&gt;

&lt;p&gt;I implemented rate limiting to restrict repeated requests.&lt;/p&gt;

&lt;p&gt;When the limit is exceeded, the application returns:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;429 Too Many Requests&lt;/code&gt;&lt;/p&gt;
&lt;h3&gt;
  
  
  JWT Storage
&lt;/h3&gt;

&lt;p&gt;A common approach is to store JWTs in &lt;code&gt;localStorage&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;However, JavaScript running on the page can access this storage. If an XSS vulnerability exists, an attacker may be able to steal the token.&lt;/p&gt;

&lt;p&gt;For this project, I used an HttpOnly cookie so that client-side JavaScript could not directly read the token.&lt;/p&gt;
&lt;h3&gt;
  
  
  Preventing Duplicate Appointments
&lt;/h3&gt;

&lt;p&gt;Imagine two patients trying to book the same doctor's appointment slot at exactly the same time.&lt;/p&gt;

&lt;p&gt;A simple availability check is not enough.&lt;/p&gt;

&lt;p&gt;Both requests might check the database before either one saves the appointment. Both could see the slot as available.&lt;/p&gt;

&lt;p&gt;This is a race condition.&lt;/p&gt;

&lt;p&gt;I used a database-level UNIQUE constraint to enforce the appointment slot rule.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;&lt;span class="nd"&gt;@Column&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"active_slot_id"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;unique&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="n"&gt;activeSlotId&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The database becomes the final authority: only one request can successfully claim the same slot.&lt;/p&gt;

&lt;h3&gt;
  
  
  Preventing Unauthorized Data Access
&lt;/h3&gt;

&lt;p&gt;A patient should never be able to access another patient's information simply by changing an ID in the URL.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;GET /api/patients/5&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;What happens if the patient changes &lt;code&gt;5&lt;/code&gt; to &lt;code&gt;6&lt;/code&gt;?&lt;/p&gt;

&lt;p&gt;This is a common form of IDOR (Insecure Direct Object Reference).&lt;/p&gt;

&lt;p&gt;Role-based authorization alone is not enough. We also need ownership checks.&lt;/p&gt;

&lt;p&gt;I used authorization logic similar to:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;&lt;span class="nd"&gt;@PreAuthorize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="s2"&gt;"hasRole('ADMIN') or @securityService.isPatientOwner(#id)"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The application checks whether the authenticated user is actually allowed to access the requested record.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. The Application Went Down
&lt;/h2&gt;

&lt;p&gt;Now, back to the incident.&lt;/p&gt;

&lt;p&gt;I opened the deployment dashboard and noticed that the recent deployments were failing.&lt;/p&gt;

&lt;p&gt;My first assumption was that one of my code changes had caused the problem.&lt;/p&gt;

&lt;p&gt;But instead of immediately changing code, I asked a different question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;When did the failure actually begin?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I checked the first failed deployment.&lt;/p&gt;

&lt;p&gt;The commit only contained a small change in the appointment service. Nothing there explained why the application could not start.&lt;/p&gt;

&lt;p&gt;The tests were also passing.&lt;/p&gt;

&lt;p&gt;So I started looking outside the application code.&lt;/p&gt;

&lt;p&gt;The backend had one important external dependency: its database.&lt;/p&gt;

&lt;p&gt;I opened the Aiven dashboard.&lt;/p&gt;

&lt;p&gt;The database was powered off.&lt;/p&gt;

&lt;p&gt;It turned out that the free plan automatically stopped services after a period of inactivity.&lt;/p&gt;

&lt;p&gt;The backend could not establish a database connection during startup, so every deployment failed.&lt;/p&gt;

&lt;p&gt;The fix was simple:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Start the database.&lt;/li&gt;
&lt;li&gt;Deploy the application again.&lt;/li&gt;
&lt;li&gt;Verify that the application could connect successfully.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The application was working again.&lt;/p&gt;

&lt;p&gt;But the incident revealed a much bigger problem.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. What Else Had I Missed?
&lt;/h2&gt;

&lt;p&gt;The application was back online, but I wanted to understand whether there were other issues hidden in the project.&lt;/p&gt;

&lt;p&gt;So I reviewed it again.&lt;/p&gt;

&lt;p&gt;I found two actual business logic problems.&lt;/p&gt;

&lt;h3&gt;
  
  
  Problem 1: Patients Could Change Appointment Status Incorrectly
&lt;/h3&gt;

&lt;p&gt;Patients could update the status of their own appointments.&lt;/p&gt;

&lt;p&gt;That included marking an appointment as completed.&lt;/p&gt;

&lt;p&gt;The ownership check was working, but ownership alone did not define which operations a user was allowed to perform.&lt;/p&gt;

&lt;p&gt;I changed the rules so patients could only cancel their appointments.&lt;/p&gt;

&lt;h3&gt;
  
  
  Problem 2: Doctors Were Never Receiving Their Temporary Passwords
&lt;/h3&gt;

&lt;p&gt;This was more serious.&lt;/p&gt;

&lt;p&gt;When an administrator approved a doctor application, the system generated a temporary password and returned a message saying that the password had been sent.&lt;/p&gt;

&lt;p&gt;But no email was actually being sent.&lt;/p&gt;

&lt;p&gt;The doctor was approved but could not access the system.&lt;/p&gt;

&lt;p&gt;The problem was not immediately obvious because the existing tests only checked that the password was not exposed in the API response.&lt;/p&gt;

&lt;p&gt;They did not verify that the doctor actually received it.&lt;/p&gt;

&lt;p&gt;I fixed the workflow so the temporary password was sent to the doctor's email address.&lt;/p&gt;

&lt;p&gt;This taught me something important:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A test can pass while the actual business process is still broken.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Another Lesson: Database Schema Validation
&lt;/h2&gt;

&lt;p&gt;I also wanted Hibernate to validate the production database schema instead of automatically modifying it.&lt;/p&gt;

&lt;p&gt;However, enabling &lt;code&gt;ddl-auto=validate&lt;/code&gt; caused the application to fail during startup.&lt;/p&gt;

&lt;p&gt;Why?&lt;/p&gt;

&lt;p&gt;The production database had changed over time and no longer matched the schema represented by the migration files.&lt;/p&gt;

&lt;p&gt;I temporarily reverted the change.&lt;/p&gt;

&lt;p&gt;The correct next step was to reconcile the actual production schema with the migration history before enabling validation.&lt;/p&gt;

&lt;p&gt;This was another reminder that database schema management requires careful attention.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. What Did I Learn?
&lt;/h2&gt;

&lt;p&gt;This incident changed how I think about production systems.&lt;/p&gt;

&lt;p&gt;Here are three lessons I took away:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Investigate the first failure, not just the latest change.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The most recent commit is not always the reason an application goes down.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Your application is more than your code.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Databases, hosting providers, deployment environments, and external services are all part of the system.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Passing tests does not mean everything works.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A test only proves the behavior it actually checks. If an important business scenario is missing, the test suite cannot protect you from it.&lt;/p&gt;

&lt;p&gt;My next step is to add regular health monitoring and alerts so that I know when the application becomes unavailable.&lt;/p&gt;

&lt;p&gt;Because a production system that nobody monitors can fail without anyone noticing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Have you ever encountered a production issue that had nothing to do with your latest code change?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I'd be interested to hear what happened and how you diagnosed it.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Project source code: &lt;a href="https://github.com/akifkeklik/hospital-management-system" rel="noopener noreferrer"&gt;Hospital Management System&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>backend</category>
      <category>database</category>
      <category>security</category>
    </item>
  </channel>
</rss>
