<?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: Oleksandr</title>
    <description>The latest articles on DEV Community by Oleksandr (@alexcodebytes).</description>
    <link>https://dev.to/alexcodebytes</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%2F4134414%2F911e1774-b09d-4120-80e9-56cc4a11b28c.png</url>
      <title>DEV Community: Oleksandr</title>
      <link>https://dev.to/alexcodebytes</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/alexcodebytes"/>
    <language>en</language>
    <item>
      <title>The "LGTM" Epidemic: Why Your Code Reviews Are Just Rubber Stamps</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Sat, 21 Nov 2026 15:10:27 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/the-lgtm-epidemic-why-your-code-reviews-are-just-rubber-stamps-3k1m</link>
      <guid>https://dev.to/alexcodebytes/the-lgtm-epidemic-why-your-code-reviews-are-just-rubber-stamps-3k1m</guid>
      <description>&lt;p&gt;Imagine this. It’s Tuesday morning. You’re sipping your coffee, feeling good. Then, the Slack notification hits: a P1 incident. Production is down. &lt;/p&gt;

&lt;p&gt;You jump into the war room. Everyone is panicking. You dig through the logs, trace the stack trace, and finally find the culprit. It’s a stupidly simple bug. A missing null check. Or a wrong variable name. &lt;/p&gt;

&lt;p&gt;Then comes the gut punch: you check the Git history. This code was merged two weeks ago. It had been approved by &lt;em&gt;three&lt;/em&gt; senior engineers. The PR had a green checkmark. The tests passed. &lt;/p&gt;

&lt;p&gt;How did this happen? &lt;/p&gt;

&lt;p&gt;Because everyone just commented &lt;strong&gt;"LGTM"&lt;/strong&gt; and moved on with their day. &lt;/p&gt;

&lt;p&gt;We’ve all been there. I’ve been there. I’ve been the one who approved a 500-line PR in 45 seconds because I was rushing to my next meeting. But this "Looks Good To Me" culture is slowly rotting our codebases, and we need to talk about it.&lt;/p&gt;

&lt;h3&gt;
  
  
  The illusion of "Four Eyes"
&lt;/h3&gt;

&lt;p&gt;The whole point of code review is to catch what the author missed. It’s supposed to be a safety net. But in reality, it often becomes a performative ritual. &lt;/p&gt;

&lt;p&gt;Why do we do it? &lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;The Bottleneck Fear:&lt;/strong&gt; Nobody wants to be the guy who blocks a release because of a minor naming convention. We feel pressured to approve quickly so the team can ship.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cognitive Overload:&lt;/strong&gt; If you send me a PR with 40 changed files, my brain just shuts down. I can’t review that properly, so I just scan it and hit approve, hoping for the best.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The "It Compiles" Mentality:&lt;/strong&gt; If the CI/CD pipeline is green and the tests pass, we assume it works. We forget that tests only prove the code does what the author &lt;em&gt;thought&lt;/em&gt; it should do — not what it &lt;em&gt;actually&lt;/em&gt; needs to do.&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  The math of the "Rubber Stamp"
&lt;/h3&gt;

&lt;p&gt;Let's look at the uncomfortable reality of how we actually review code versus how we &lt;em&gt;think&lt;/em&gt; we do:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;PR Size (Lines of Code)&lt;/th&gt;
&lt;th&gt;Average Review Time&lt;/th&gt;
&lt;th&gt;Actual Review Quality&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;1 - 50 lines&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;15 - 30 mins&lt;/td&gt;
&lt;td&gt;High. Real questions are asked.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;50 - 200 lines&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;10 - 15 mins&lt;/td&gt;
&lt;td&gt;Medium. Major logic is checked, edge cases ignored.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;200 - 500 lines&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;5 - 8 mins&lt;/td&gt;
&lt;td&gt;Low. Skimming for typos.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;500+ lines&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&amp;lt; 2 mins&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;LGTM.&lt;/strong&gt; (Please just let me close this tab).&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;When a PR gets too big, the reviewer’s brain switches from "analytical" to "survival mode". We stop looking for logic errors and start looking for reasons to just approve it and move on.&lt;/p&gt;

&lt;h3&gt;
  
  
  A code review is not a proofreading session
&lt;/h3&gt;

&lt;p&gt;Here is what a typical "LGTM" review looks like in the wild:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight diff"&gt;&lt;code&gt;&lt;span class="gi"&gt;+ // Adding a new caching layer for user profiles&lt;/span&gt;
&lt;span class="gi"&gt;+ const user = await getUserFromCache(userId);&lt;/span&gt;
&lt;span class="gi"&gt;+ if (user) {&lt;/span&gt;
&lt;span class="gi"&gt;+    return user; &lt;/span&gt;
&lt;span class="gi"&gt;+ }&lt;/span&gt;
&lt;span class="gi"&gt;+ // Fallback to DB&lt;/span&gt;
&lt;span class="gi"&gt;+ const dbUser = await fetchFromDB(userId);&lt;/span&gt;
&lt;span class="gi"&gt;+ await setUserInCache(userId, dbUser);&lt;/span&gt;
&lt;span class="gi"&gt;+ return dbUser;&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;The Reviewer:&lt;/strong&gt; "LGTM 👍" (Approved).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What the reviewer missed:&lt;/strong&gt; dbUser could be null if the user doesn't exist, which means we are caching null and returning it, causing a silent failure on the frontend three calls later.&lt;/p&gt;

&lt;p&gt;The author had all the context in their head, so it looked fine to them. The reviewer just glanced at the syntax, saw that it "makes sense", and approved it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do we fix the "LGTM" epidemic?&lt;/strong&gt;&lt;br&gt;
I don't think the answer is "just be more careful." That's like telling someone to "just be happier." We need structural changes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Ban the LGTM comment.&lt;/strong&gt;&lt;br&gt;
Seriously. Make it a team rule. If you are approving a PR, you must leave a comment explaining what you checked. Even if it’s just: "Checked the DB calls and the error handling looks correct. Tested locally, works as expected." This forces the reviewer's brain to actually engage with the code, even for a few seconds.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Enforce the 200-line rule.&lt;/strong&gt;&lt;br&gt;
If a PR is over 200 lines of actual logic (excluding generated files, lockfiles, etc.), it gets rejected automatically. It must be split. Reviewing smaller chunks is the only way to maintain quality without burning out your seniors.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Ask a real question.&lt;/strong&gt;&lt;br&gt;
The best code reviews are the ones where the reviewer asks, "Why did you choose this approach instead of X?" or "What happens if this API call times out?" If you can't think of a single question to ask about a PR, it probably means you didn't read it carefully enough.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. The "Rubber Duck" review.&lt;/strong&gt;&lt;br&gt;
Before you assign a reviewer, explain your own PR in the comments. Write a short paragraph: "Hey, this PR does X. The tricky part was Y, so I handled it by doing Z. Please pay special attention to the database transaction on line 45." This guides the reviewer exactly where to look and prevents them from getting lost.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It’s about culture, not tools&lt;/strong&gt;&lt;br&gt;
You can have the fanciest CI/CD pipeline, the most strict linters, and the best AI code review bots (yes, even Claude or Copilot). But if your human reviewers are just acting as a human LGTM button, your codebase is a ticking time bomb.&lt;/p&gt;

&lt;p&gt;Code reviews are not a gate to pass; they are a conversation about the code. And a conversation requires more than just saying "Looks good."&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Let's discuss&lt;/strong&gt;&lt;br&gt;
I'm curious how other teams handle this.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do you have a team culture where it’s acceptable to block a PR for a whole day just to ask questions?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is your "hard limit" for PR size before you hit that reject button?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Have you ever caught a catastrophic bug in a review that the CI completely missed? What was it?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I'd love to hear your war stories. Because at the end of the day, the best code review is the one that prevents you from getting that 3 AM PagerDuty alert.&lt;/p&gt;

</description>
      <category>discuss</category>
      <category>webdev</category>
      <category>cleancode</category>
      <category>career</category>
    </item>
    <item>
      <title>Your App Is Online. So Why Can't Anyone Use It?</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Sat, 21 Nov 2026 05:27:31 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/your-app-is-online-so-why-cant-anyone-use-it-73o</link>
      <guid>https://dev.to/alexcodebytes/your-app-is-online-so-why-cant-anyone-use-it-73o</guid>
      <description>&lt;p&gt;Imagine checking your production dashboard on a Monday morning.&lt;/p&gt;

&lt;p&gt;Server uptime: 100%.&lt;/p&gt;

&lt;p&gt;API health checks: passing.&lt;/p&gt;

&lt;p&gt;Database: connected.&lt;/p&gt;

&lt;p&gt;Error rate: within normal limits.&lt;/p&gt;

&lt;p&gt;Response times: looking good.&lt;/p&gt;

&lt;p&gt;Everything is green.&lt;/p&gt;

&lt;p&gt;Then a customer reports that they cannot complete a purchase.&lt;/p&gt;

&lt;p&gt;You investigate. The homepage loads. Product pages open. The API responds. Authentication works.&lt;/p&gt;

&lt;p&gt;But the checkout process gets stuck after the customer confirms their address.&lt;/p&gt;

&lt;p&gt;Your monitoring says the application is healthy.&lt;/p&gt;

&lt;p&gt;Your customer says it is broken.&lt;/p&gt;

&lt;p&gt;And both observations can be technically correct.&lt;/p&gt;

&lt;p&gt;The problem with measuring whether software is alive&lt;/p&gt;

&lt;p&gt;Most monitoring systems are designed to answer specific questions:&lt;/p&gt;

&lt;p&gt;Is the server responding?&lt;/p&gt;

&lt;p&gt;Is the database reachable?&lt;/p&gt;

&lt;p&gt;Is the API returning successful responses?&lt;/p&gt;

&lt;p&gt;Are response times within acceptable limits?&lt;/p&gt;

&lt;p&gt;Are errors increasing?&lt;/p&gt;

&lt;p&gt;These are important questions. Nobody should stop monitoring infrastructure health.&lt;/p&gt;

&lt;p&gt;But they don't necessarily answer the question that matters most:&lt;/p&gt;

&lt;p&gt;Can someone actually use the product to accomplish what they came here to do?&lt;/p&gt;

&lt;p&gt;An application isn't a collection of independent endpoints from the user's perspective.&lt;/p&gt;

&lt;p&gt;It's a sequence of connected actions.&lt;/p&gt;

&lt;p&gt;A customer doesn't care that five API calls succeeded if the sixth one prevents them from completing an order.&lt;/p&gt;

&lt;p&gt;A student doesn't care that the learning platform is online if their submitted assignment never gets saved.&lt;/p&gt;

&lt;p&gt;A developer doesn't care that the deployment dashboard is healthy if the application silently serves outdated data.&lt;/p&gt;

&lt;p&gt;The system can remain technically available while its most important functionality is broken.&lt;/p&gt;

&lt;p&gt;How a healthy system can produce a broken experience&lt;/p&gt;

&lt;p&gt;Consider a few hypothetical scenarios.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Every component works, but the workflow doesn't&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Imagine an online store.&lt;/p&gt;

&lt;p&gt;The following operations all work:&lt;/p&gt;

&lt;p&gt;Product search.&lt;/p&gt;

&lt;p&gt;Product details.&lt;/p&gt;

&lt;p&gt;Customer authentication.&lt;/p&gt;

&lt;p&gt;Shopping cart retrieval.&lt;/p&gt;

&lt;p&gt;Address validation.&lt;/p&gt;

&lt;p&gt;Payment provider connection.&lt;/p&gt;

&lt;p&gt;Individual health checks pass.&lt;/p&gt;

&lt;p&gt;However, the checkout process fails because the frontend sends an address identifier that the order service no longer recognizes.&lt;/p&gt;

&lt;p&gt;Neither service is necessarily unhealthy.&lt;/p&gt;

&lt;p&gt;The integration between them is broken.&lt;/p&gt;

&lt;p&gt;This is one reason why monitoring individual components cannot replace monitoring complete user journeys.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The application returns successful responses containing bad information&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;An API can return HTTP 200 while delivering information that is technically valid but functionally incorrect.&lt;/p&gt;

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

&lt;p&gt;A dashboard displays yesterday's figures instead of today's.&lt;/p&gt;

&lt;p&gt;An inventory service returns an old stock count.&lt;/p&gt;

&lt;p&gt;A search endpoint returns results but excludes recently added records.&lt;/p&gt;

&lt;p&gt;A notification service reports successful delivery before the message actually reaches its destination.&lt;/p&gt;

&lt;p&gt;From an infrastructure perspective, these operations may look successful.&lt;/p&gt;

&lt;p&gt;From a product perspective, they can be failures.&lt;/p&gt;

&lt;p&gt;A successful response is not necessarily a successful outcome.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Partial failures are difficult to notice&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Modern applications depend on multiple services.&lt;/p&gt;

&lt;p&gt;A single user action might involve a frontend, authentication provider, database, background worker, external API, and notification system.&lt;/p&gt;

&lt;p&gt;If one dependency becomes slow or unreliable, the entire experience can deteriorate without the application going completely offline.&lt;/p&gt;

&lt;p&gt;For example, a background worker might stop processing jobs.&lt;/p&gt;

&lt;p&gt;The main application continues responding normally.&lt;/p&gt;

&lt;p&gt;Users can submit requests, but the results never arrive.&lt;/p&gt;

&lt;p&gt;The problem may remain invisible until someone notices that their task has been waiting for an unusually long time.&lt;/p&gt;

&lt;p&gt;This is particularly dangerous when the system acknowledges an action before its final result is available.&lt;/p&gt;

&lt;p&gt;Monitor outcomes, not just components&lt;/p&gt;

&lt;p&gt;I don't think the solution is to replace infrastructure monitoring.&lt;/p&gt;

&lt;p&gt;It's to add another layer.&lt;/p&gt;

&lt;p&gt;Instead of checking only whether individual components are functioning, monitor whether important user journeys are completing successfully.&lt;/p&gt;

&lt;p&gt;For an online store, that might mean checking:&lt;/p&gt;

&lt;p&gt;User journey&lt;/p&gt;

&lt;p&gt;What to verify&lt;/p&gt;

&lt;p&gt;Registration&lt;/p&gt;

&lt;p&gt;A new account can actually be created&lt;/p&gt;

&lt;p&gt;Login&lt;/p&gt;

&lt;p&gt;The user can authenticate and access their account&lt;/p&gt;

&lt;p&gt;Search&lt;/p&gt;

&lt;p&gt;Relevant results are returned&lt;/p&gt;

&lt;p&gt;Checkout&lt;/p&gt;

&lt;p&gt;An order reaches the expected final state&lt;/p&gt;

&lt;p&gt;Payment&lt;/p&gt;

&lt;p&gt;The transaction has a confirmed outcome&lt;/p&gt;

&lt;p&gt;Order history&lt;/p&gt;

&lt;p&gt;The completed order appears correctly&lt;/p&gt;

&lt;p&gt;Notice the difference.&lt;/p&gt;

&lt;p&gt;A basic health check might confirm that the payment endpoint responds.&lt;/p&gt;

&lt;p&gt;A workflow check should verify that a test transaction reaches the expected state without creating unintended charges.&lt;/p&gt;

&lt;p&gt;These are different levels of confidence.&lt;/p&gt;

&lt;p&gt;Five things worth monitoring beyond uptime&lt;/p&gt;

&lt;p&gt;If I were reviewing the monitoring strategy of an existing application, I'd start with these areas.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Completion rate&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;How many users who start an important workflow actually finish it?&lt;/p&gt;

&lt;p&gt;A sudden drop can reveal problems that ordinary availability metrics miss.&lt;/p&gt;

&lt;p&gt;However, completion rates need context. A change in user behavior, traffic composition, or product design can also affect them.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Time to successful completion&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;It's not enough for an operation to eventually succeed.&lt;/p&gt;

&lt;p&gt;If a task normally takes a few seconds but now takes several minutes, the application may be technically available while becoming practically unusable.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Data freshness&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;When was the information last updated?&lt;/p&gt;

&lt;p&gt;This matters especially for dashboards, inventory, financial systems, search indexes, and applications that depend on background processing.&lt;/p&gt;

&lt;p&gt;A response containing stale information can be more dangerous than an explicit error because users may not realize anything is wrong.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Background job completion&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Track more than whether workers are running.&lt;/p&gt;

&lt;p&gt;Monitor:&lt;/p&gt;

&lt;p&gt;Jobs waiting in queues.&lt;/p&gt;

&lt;p&gt;Age of the oldest pending job.&lt;/p&gt;

&lt;p&gt;Failed and repeatedly retried jobs.&lt;/p&gt;

&lt;p&gt;Jobs that were accepted but never completed.&lt;/p&gt;

&lt;p&gt;A running worker doesn't guarantee that work is being processed correctly.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Critical integration health&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;An external dependency can be reachable while a particular operation fails.&lt;/p&gt;

&lt;p&gt;Monitor the actual interactions your product relies on, not simply whether a third-party domain responds.&lt;/p&gt;

&lt;p&gt;A practical approach: test the user's journey&lt;/p&gt;

&lt;p&gt;You don't necessarily need a complicated monitoring platform to begin.&lt;/p&gt;

&lt;p&gt;Start with one critical workflow.&lt;/p&gt;

&lt;p&gt;For example, if your product depends on users creating and retrieving records:&lt;/p&gt;

&lt;p&gt;Create a dedicated test account.&lt;/p&gt;

&lt;p&gt;Submit a uniquely identifiable test record.&lt;/p&gt;

&lt;p&gt;Verify that the system accepts it.&lt;/p&gt;

&lt;p&gt;Retrieve the record through the normal user-facing interface.&lt;/p&gt;

&lt;p&gt;Confirm that the expected data is present.&lt;/p&gt;

&lt;p&gt;Clean up the test data if appropriate.&lt;/p&gt;

&lt;p&gt;Alert someone if the workflow fails.&lt;/p&gt;

&lt;p&gt;There are important precautions.&lt;/p&gt;

&lt;p&gt;Synthetic tests should use isolated test accounts and controlled data. They should not accidentally send real notifications, charge real payment methods, or trigger irreversible business operations.&lt;/p&gt;

&lt;p&gt;They should also be designed so that repeated execution doesn't create an ever-growing collection of test records.&lt;/p&gt;

&lt;p&gt;Most importantly, a synthetic test should verify the same meaningful behavior that a real user depends on.&lt;/p&gt;

&lt;p&gt;A test that simply calls an endpoint and checks for HTTP 200 doesn't prove that the workflow works.&lt;/p&gt;

&lt;p&gt;Don't turn monitoring into another source of noise&lt;/p&gt;

&lt;p&gt;There is one more problem worth considering.&lt;/p&gt;

&lt;p&gt;If every small deviation creates an alert, the monitoring system becomes difficult to trust.&lt;/p&gt;

&lt;p&gt;Teams eventually learn to ignore notifications, including the important ones.&lt;/p&gt;

&lt;p&gt;Not every metric needs an alert.&lt;/p&gt;

&lt;p&gt;I'd distinguish between:&lt;/p&gt;

&lt;p&gt;Informational signals: something changed, but no immediate action is required.&lt;/p&gt;

&lt;p&gt;Warnings: a workflow is degrading and deserves investigation.&lt;/p&gt;

&lt;p&gt;Critical incidents: an important user action is failing or data integrity may be at risk.&lt;/p&gt;

&lt;p&gt;The thresholds should reflect the actual impact of the failure.&lt;/p&gt;

&lt;p&gt;For example, one failed synthetic test might justify a warning or a second verification attempt. Repeated failures across multiple checks might justify escalating the issue.&lt;/p&gt;

&lt;p&gt;The goal isn't to generate more alerts.&lt;/p&gt;

&lt;p&gt;It's to make important failures harder to miss.&lt;/p&gt;

&lt;p&gt;The question I'd ask before calling a system healthy&lt;/p&gt;

&lt;p&gt;Instead of asking only:&lt;/p&gt;

&lt;p&gt;"Is everything running?"&lt;/p&gt;

&lt;p&gt;I'd ask:&lt;/p&gt;

&lt;p&gt;"Can a real user complete the most important task this product promises to perform?"&lt;/p&gt;

&lt;p&gt;That question changes how we think about reliability.&lt;/p&gt;

&lt;p&gt;Infrastructure health is necessary.&lt;/p&gt;

&lt;p&gt;Successful requests are necessary.&lt;/p&gt;

&lt;p&gt;But neither automatically proves that the product is delivering its intended value.&lt;/p&gt;

&lt;p&gt;A system should be measured not only by whether its components are alive, but also by whether the outcomes users depend on are actually happening.&lt;/p&gt;

&lt;p&gt;Let's discuss&lt;/p&gt;

&lt;p&gt;I'm interested in how other developers approach this.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Have you ever had a production system where every dashboard was green, but users were still experiencing serious problems?&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Do you actively monitor complete user journeys, or do you mostly rely on infrastructure and endpoint health checks?&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;What's one important failure mode you've seen that ordinary uptime monitoring completely missed?&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;I'm especially interested in practical examples.&lt;/p&gt;

&lt;p&gt;Because sometimes the most misleading production status isn't a red dashboard.&lt;/p&gt;

&lt;p&gt;It's a perfectly green one.&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>devops</category>
      <category>discuss</category>
      <category>testing</category>
    </item>
    <item>
      <title>Your API Was Built for Developers. What Happens When AI Agents Become Its Main Users?</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Fri, 20 Nov 2026 12:59:37 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/your-api-was-built-for-developers-what-happens-when-ai-agents-become-its-main-users-4h6</link>
      <guid>https://dev.to/alexcodebytes/your-api-was-built-for-developers-what-happens-when-ai-agents-become-its-main-users-4h6</guid>
      <description>&lt;p&gt;For years, we've designed APIs around a relatively simple assumption:&lt;/p&gt;

&lt;p&gt;A developer reads the documentation, understands the available operations, writes the integration, handles errors, and decides what happens next.&lt;/p&gt;

&lt;p&gt;Now introduce an AI agent into that equation.&lt;/p&gt;

&lt;p&gt;It doesn't necessarily read your documentation from beginning to end. It may discover an endpoint through a tool definition, infer how to use it, execute several operations in sequence, interpret the responses, and decide what to do next.&lt;/p&gt;

&lt;p&gt;The API hasn't changed.&lt;/p&gt;

&lt;p&gt;But the way it's being used has changed dramatically.&lt;/p&gt;

&lt;p&gt;And I think we're approaching a point where API design needs to account for a new kind of consumer: software that can interpret instructions but doesn't always interpret them correctly.&lt;/p&gt;

&lt;h2&gt;
  
  
  The difference between an API call and an agent decision
&lt;/h2&gt;

&lt;p&gt;A traditional integration usually follows a predefined path.&lt;/p&gt;

&lt;p&gt;An agent-based integration can make decisions between operations.&lt;/p&gt;

&lt;p&gt;Consider a simple customer management API.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Operation&lt;/th&gt;
&lt;th&gt;Traditional integration&lt;/th&gt;
&lt;th&gt;AI agent&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Find a customer&lt;/td&gt;
&lt;td&gt;Uses a predefined query&lt;/td&gt;
&lt;td&gt;Interprets a request and chooses search criteria&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Update information&lt;/td&gt;
&lt;td&gt;Sends mapped fields&lt;/td&gt;
&lt;td&gt;Decides which fields should change&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Create a record&lt;/td&gt;
&lt;td&gt;Follows application logic&lt;/td&gt;
&lt;td&gt;Determines whether a new record is necessary&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Handle an error&lt;/td&gt;
&lt;td&gt;Executes predefined recovery&lt;/td&gt;
&lt;td&gt;Interprets the error and chooses another action&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Complete a workflow&lt;/td&gt;
&lt;td&gt;Follows a fixed sequence&lt;/td&gt;
&lt;td&gt;Decides when the task is finished&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The important difference isn't that an agent can send HTTP requests.&lt;/p&gt;

&lt;p&gt;It's that an agent can choose which requests to send and in what order.&lt;/p&gt;

&lt;p&gt;That creates a new architectural problem.&lt;/p&gt;

&lt;p&gt;An endpoint that works perfectly for a developer following a carefully written integration guide may behave very differently when an agent starts exploring its capabilities.&lt;/p&gt;

&lt;h2&gt;
  
  
  Five API design problems that become more important with AI agents
&lt;/h2&gt;

&lt;p&gt;I would pay particular attention to five areas.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Ambiguous operations
&lt;/h3&gt;

&lt;p&gt;Imagine an API with this endpoint:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;POST /customers/update&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;What exactly does update mean?&lt;/p&gt;

&lt;p&gt;Does it replace all fields? Modify only the supplied fields? Clear fields that are missing? Apply defaults?&lt;/p&gt;

&lt;p&gt;A human developer might investigate the implementation before using it.&lt;/p&gt;

&lt;p&gt;An agent might infer the behavior from the endpoint name and a short description.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;API behavior&lt;/th&gt;
&lt;th&gt;Possible agent interpretation&lt;/th&gt;
&lt;th&gt;Potential consequence&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Missing field&lt;/td&gt;
&lt;td&gt;Leave unchanged&lt;/td&gt;
&lt;td&gt;No modification&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Missing field&lt;/td&gt;
&lt;td&gt;Set to null&lt;/td&gt;
&lt;td&gt;Accidental data loss&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Empty string&lt;/td&gt;
&lt;td&gt;Valid value&lt;/td&gt;
&lt;td&gt;Incorrect customer data&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Empty array&lt;/td&gt;
&lt;td&gt;Remove all items&lt;/td&gt;
&lt;td&gt;Unexpected deletion&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The API should not require the consumer to guess its semantics.&lt;/p&gt;

&lt;p&gt;Explicit contracts become especially important when the consumer is making decisions autonomously.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Permissions that are too broad
&lt;/h3&gt;

&lt;p&gt;Many APIs use access tokens with permissions that are convenient for developers but unnecessarily powerful for autonomous systems.&lt;/p&gt;

&lt;p&gt;An agent that needs to read customer information might also receive permission to delete customers or modify billing settings.&lt;/p&gt;

&lt;p&gt;That is a very different risk profile.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Permission model&lt;/th&gt;
&lt;th&gt;What it allows&lt;/th&gt;
&lt;th&gt;Risk&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Broad access token&lt;/td&gt;
&lt;td&gt;Multiple unrelated operations&lt;/td&gt;
&lt;td&gt;Large potential impact&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Resource-level permissions&lt;/td&gt;
&lt;td&gt;Access to selected resources&lt;/td&gt;
&lt;td&gt;Reduced exposure&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Action-level permissions&lt;/td&gt;
&lt;td&gt;Specific operations only&lt;/td&gt;
&lt;td&gt;More controlled behavior&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Temporary authorization&lt;/td&gt;
&lt;td&gt;Access for a limited period or task&lt;/td&gt;
&lt;td&gt;Smaller exposure window&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;I would argue that AI-facing integrations should increasingly use permissions based on the specific task, rather than simply inheriting the permissions of the account owner.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Retries can become expensive
&lt;/h3&gt;

&lt;p&gt;Retries are normal in API integrations.&lt;/p&gt;

&lt;p&gt;But an agent may not always understand whether an operation actually succeeded.&lt;/p&gt;

&lt;p&gt;Consider a payment request:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The agent sends a payment request.&lt;/li&gt;
&lt;li&gt;The server processes the payment.&lt;/li&gt;
&lt;li&gt;The connection times out before the response arrives.&lt;/li&gt;
&lt;li&gt;The agent assumes the operation failed.&lt;/li&gt;
&lt;li&gt;It sends the request again.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Now the customer may have been charged twice.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Failure scenario&lt;/th&gt;
&lt;th&gt;Naive retry&lt;/th&gt;
&lt;th&gt;Safer design&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Read request times out&lt;/td&gt;
&lt;td&gt;Retry&lt;/td&gt;
&lt;td&gt;Retry with limits&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Payment response is lost&lt;/td&gt;
&lt;td&gt;Send payment again&lt;/td&gt;
&lt;td&gt;Idempotency key&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Record creation is uncertain&lt;/td&gt;
&lt;td&gt;Create another record&lt;/td&gt;
&lt;td&gt;Check operation status&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Long-running task times out&lt;/td&gt;
&lt;td&gt;Start another task&lt;/td&gt;
&lt;td&gt;Retrieve existing task state&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This is why idempotency, operation identifiers, and clear execution states should not be treated as optional implementation details.&lt;/p&gt;

&lt;p&gt;They are fundamental safeguards.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Errors need to explain what can happen next
&lt;/h3&gt;

&lt;p&gt;A response containing only &lt;code&gt;400 Bad Request&lt;/code&gt; gives an agent very little useful information.&lt;/p&gt;

&lt;p&gt;Even a detailed error message may not be enough if it doesn't explain whether the operation can be safely retried or corrected.&lt;/p&gt;

&lt;p&gt;Consider the difference:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Response&lt;/th&gt;
&lt;th&gt;Information provided&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;400 Bad Request&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Something was wrong&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;422 Invalid field: email&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Identifies the invalid field&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;409 Resource version conflict&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Explains the conflict&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;429 Rate limit exceeded&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Indicates temporary restriction&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;403 Approval required&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Indicates that another authorization step is needed&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A useful API error should help the consumer distinguish between:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A request that should be corrected.&lt;/li&gt;
&lt;li&gt;An operation that can be retried.&lt;/li&gt;
&lt;li&gt;An operation that requires human approval.&lt;/li&gt;
&lt;li&gt;An operation that may already have completed.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Without that distinction, an agent can turn a small failure into a much larger one.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. The API needs to explain what actually happened
&lt;/h3&gt;

&lt;p&gt;Traditional API responses often focus on returning the requested data.&lt;/p&gt;

&lt;p&gt;Agent workflows need something else as well: a reliable record of what happened.&lt;/p&gt;

&lt;p&gt;For example, an agent may request an update and receive a successful response.&lt;/p&gt;

&lt;p&gt;But did the system update every field? Did a validation rule modify the input? Was another process triggered? Did the operation complete immediately or enter a queue?&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Information&lt;/th&gt;
&lt;th&gt;Why it matters&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Operation ID&lt;/td&gt;
&lt;td&gt;Identifies the specific action&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Execution status&lt;/td&gt;
&lt;td&gt;Shows whether it completed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Changed fields&lt;/td&gt;
&lt;td&gt;Makes modifications visible&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Timestamp&lt;/td&gt;
&lt;td&gt;Establishes when it happened&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Actor identity&lt;/td&gt;
&lt;td&gt;Identifies who initiated the operation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Resulting resource version&lt;/td&gt;
&lt;td&gt;Helps detect later changes&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This isn't just about debugging.&lt;/p&gt;

&lt;p&gt;It's about making autonomous actions understandable and auditable.&lt;/p&gt;

&lt;h2&gt;
  
  
  A different way to evaluate API quality
&lt;/h2&gt;

&lt;p&gt;I think traditional API evaluation focuses heavily on developer experience, performance, documentation, and reliability.&lt;/p&gt;

&lt;p&gt;Those things still matter.&lt;/p&gt;

&lt;p&gt;But when AI agents become important API consumers, I would add another evaluation dimension.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Evaluation area&lt;/th&gt;
&lt;th&gt;Traditional question&lt;/th&gt;
&lt;th&gt;Additional AI-era question&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Documentation&lt;/td&gt;
&lt;td&gt;Can developers understand it?&lt;/td&gt;
&lt;td&gt;Can an agent discover the correct operation?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Validation&lt;/td&gt;
&lt;td&gt;Are invalid requests rejected?&lt;/td&gt;
&lt;td&gt;Are ambiguous requests prevented?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Permissions&lt;/td&gt;
&lt;td&gt;Can users access their resources?&lt;/td&gt;
&lt;td&gt;Can an agent access only what its task requires?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Reliability&lt;/td&gt;
&lt;td&gt;Does the endpoint work consistently?&lt;/td&gt;
&lt;td&gt;Can uncertain outcomes be safely resolved?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Errors&lt;/td&gt;
&lt;td&gt;Are failures reported?&lt;/td&gt;
&lt;td&gt;Can the consumer determine the correct next step?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Observability&lt;/td&gt;
&lt;td&gt;Can requests be monitored?&lt;/td&gt;
&lt;td&gt;Can every autonomous action be reconstructed?&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This doesn't mean every API needs to become an AI-specific API.&lt;/p&gt;

&lt;p&gt;In fact, I suspect the best approach will often be to improve the underlying API contract so that both humans and automated systems benefit.&lt;/p&gt;

&lt;h2&gt;
  
  
  The uncomfortable question: should agents have fewer freedoms than developers?
&lt;/h2&gt;

&lt;p&gt;Here's where I think the discussion gets interesting.&lt;/p&gt;

&lt;p&gt;A developer can understand business context, recognize unusual situations, and decide not to execute an operation even when the API technically permits it.&lt;/p&gt;

&lt;p&gt;An AI agent may not reliably recognize the same boundaries.&lt;/p&gt;

&lt;p&gt;So perhaps we should stop treating API access as a simple question of authentication.&lt;/p&gt;

&lt;p&gt;Instead, we should consider the level of autonomy an integration is allowed to exercise.&lt;/p&gt;

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

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Autonomy level&lt;/th&gt;
&lt;th&gt;Agent capability&lt;/th&gt;
&lt;th&gt;Human involvement&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Level 1&lt;/td&gt;
&lt;td&gt;Read and retrieve information&lt;/td&gt;
&lt;td&gt;None for permitted reads&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Level 2&lt;/td&gt;
&lt;td&gt;Prepare proposed changes&lt;/td&gt;
&lt;td&gt;Approves changes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Level 3&lt;/td&gt;
&lt;td&gt;Execute reversible operations&lt;/td&gt;
&lt;td&gt;Reviews exceptions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Level 4&lt;/td&gt;
&lt;td&gt;Execute selected irreversible operations&lt;/td&gt;
&lt;td&gt;Explicit authorization required&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This is only one possible model, but it raises an important design question: should an API expose the same operations to every authenticated consumer, or should it distinguish between human-driven and autonomous access?&lt;/p&gt;

&lt;h2&gt;
  
  
  What I would change first
&lt;/h2&gt;

&lt;p&gt;If I were designing an API today with future AI integrations in mind, I wouldn't start by adding an AI endpoint.&lt;/p&gt;

&lt;p&gt;I'd start with:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Explicit request and response schemas.&lt;/li&gt;
&lt;li&gt;Strict validation and predictable error semantics.&lt;/li&gt;
&lt;li&gt;Idempotency for operations that can cause side effects.&lt;/li&gt;
&lt;li&gt;Narrow, task-specific permissions.&lt;/li&gt;
&lt;li&gt;Operation IDs and execution-status tracking.&lt;/li&gt;
&lt;li&gt;Audit logs that connect actions to their initiating agent.&lt;/li&gt;
&lt;li&gt;Human approval mechanisms for high-impact operations.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;None of these ideas requires an AI model.&lt;/p&gt;

&lt;p&gt;But together, they make an API much safer and more predictable when an AI model eventually starts using it.&lt;/p&gt;

&lt;p&gt;And that might be a more valuable investment than building another layer of AI abstraction on top of an unclear API.&lt;/p&gt;

&lt;h2&gt;
  
  
  Let's discuss
&lt;/h2&gt;

&lt;p&gt;I have three questions for developers building APIs, integrations, MCP servers, and agent-based applications:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Should AI agents receive a separate permission model, or should they use exactly the same authorization system as human users?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Who should be responsible when an agent makes a technically valid API call that produces an unintended business outcome: the agent developer, the API provider, or the organization that authorized the agent?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. If you could introduce just one new requirement for every API intended to be used by AI agents, what would it be?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I'm particularly interested in real implementation experiences rather than predictions.&lt;/p&gt;

&lt;p&gt;Because the next generation of API problems might not come from requests that fail.&lt;/p&gt;

&lt;p&gt;They might come from requests that succeed exactly as designed — but shouldn't have been made in the first place.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>api</category>
      <category>architecture</category>
    </item>
    <item>
      <title>Why I Ditched Subscriptions for One-Time Payments (And Why You Should Too)</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Mon, 16 Nov 2026 09:24:40 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/why-i-ditched-subscriptions-for-one-time-payments-and-why-you-should-too-1e8g</link>
      <guid>https://dev.to/alexcodebytes/why-i-ditched-subscriptions-for-one-time-payments-and-why-you-should-too-1e8g</guid>
      <description>&lt;p&gt;Every developer building a SaaS dreams of MRR (Monthly Recurring Revenue). The idea of passive income is intoxicating. You build the product once, and you get paid every month forever, right?&lt;/p&gt;

&lt;p&gt;In reality, subscriptions are a massive technical and psychological trap.&lt;/p&gt;

&lt;p&gt;After spending months building a subscription-based system for my side project, I realized I was spending more time managing billing than building features. I decided to delete the entire subscription logic and switch to a one-time payment model. Here is why.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Technical Debt of Subscriptions&lt;/strong&gt;&lt;br&gt;
When you decide to charge monthly, you are no longer just a developer. You are a billing engineer.&lt;/p&gt;

&lt;p&gt;You suddenly have to handle:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Proration:&lt;/strong&gt; What happens if a user upgrades from Basic to Pro on the 15th of the month?&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Dunning Management:&lt;/strong&gt; What happens when a credit card expires? You have to build logic to retry payments, send emails, and downgrade accounts.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Webhooks:&lt;/strong&gt; You have to perfectly handle invoice.payment_succeeded, invoice.payment_failed, customer.subscription.updated, and a dozen other Stripe webhooks.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cancellation Flows:&lt;/strong&gt; Building the UI to let people cancel without accidentally canceling them due to a bug.&lt;/p&gt;

&lt;p&gt;I spent 40% of my dev time on billing edge cases instead of making the product better.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Psychological Tax&lt;/strong&gt;&lt;br&gt;
Then comes the churn. Every morning, you wake up and look at the dashboard. Did anyone cancel? Why did they cancel? Are they mad about a bug?&lt;/p&gt;

&lt;p&gt;You are constantly anxious about keeping people on a subscription they might not even need. It forces you to optimize for "stickiness" (dark patterns, making it hard to cancel) rather than actually solving the user's problem.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Shift: Back to One-Time Payments&lt;/strong&gt;&lt;br&gt;
I ripped out the subscription logic. I set up a simple Stripe Checkout link for a one-time payment.&lt;/p&gt;

&lt;p&gt;The result was immediate:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Zero churn:&lt;/strong&gt; If someone buys, they buy. End of story. My revenue is locked in.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;No billing bugs:&lt;/strong&gt; No more proration errors or failed webhook retries.&lt;/p&gt;

&lt;p&gt;**Better customers: **People who pay $49 once are serious about solving their problem. They don't feel "locked in," so they are less likely to be angry.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Code&lt;/strong&gt;&lt;br&gt;
My backend logic went from 500 lines of webhook handling to this:&lt;br&gt;
// Using Stripe Checkout for one-time payments&lt;br&gt;
const session = await stripe.checkout.sessions.create({&lt;br&gt;
  payment_method_types: ['card'],&lt;br&gt;
  line_items: [{ price: 'price_12345', quantity: 1 }],&lt;br&gt;
  mode: 'payment',&lt;br&gt;
  success_url: '&lt;a href="https://landings.jsonexlab.com/thank-you/" rel="noopener noreferrer"&gt;https://landings.jsonexlab.com/thank-you/&lt;/a&gt;',&lt;br&gt;
  cancel_url: '&lt;a href="https://landings.jsonexlab.com/" rel="noopener noreferrer"&gt;https://landings.jsonexlab.com/&lt;/a&gt;',&lt;br&gt;
});&lt;br&gt;
That's it. No subscription databases. No cron jobs for failed payments.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Who is this for?&lt;/strong&gt;&lt;br&gt;
If you are building enterprise software (like Slack or Figma), subscriptions make sense because the product is expensive to run, and you provide continuous updates.&lt;/p&gt;

&lt;p&gt;But if you are building a digital asset (like a Notion template, a PDF, or a small tool), one-time payments are vastly superior.&lt;/p&gt;

&lt;p&gt;If you want to see how I structure my digital products for one-time sales, check out my Dev Launch Kit. It includes the exact steps I used to ship and sell without building a billing backend.&lt;/p&gt;

&lt;p&gt;Stop building billing systems. Start building products.&lt;/p&gt;

</description>
      <category>saas</category>
      <category>stripe</category>
    </item>
    <item>
      <title>Why Your Side Project Has 0 Users (And Why It’s Not a Coding Problem)</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Sat, 14 Nov 2026 15:40:17 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/why-your-side-project-has-0-users-and-why-its-not-a-coding-problem-11ci</link>
      <guid>https://dev.to/alexcodebytes/why-your-side-project-has-0-users-and-why-its-not-a-coding-problem-11ci</guid>
      <description>&lt;p&gt;I spent three months building the perfect API. It had clean architecture, 99% test coverage, and a beautiful CI/CD pipeline. I deployed it, leaned back in my chair, and waited for the users to roll in.&lt;/p&gt;

&lt;p&gt;They didn't.&lt;/p&gt;

&lt;p&gt;I got exactly 0 visitors. Not a single person signed up.&lt;/p&gt;

&lt;p&gt;I see this pattern constantly in the #showdev tag. Developers (myself included) spend 90% of their time writing code and 10% of their time thinking about distribution. We think that if we just build a great product, the internet will magically discover it.&lt;/p&gt;

&lt;p&gt;But the internet doesn't care about your code. It cares about solutions to problems.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The "If You Build It" Fallacy&lt;/strong&gt;&lt;br&gt;
As engineers, we are trained to solve problems with code. So when we want to start a side project, our first instinct is to open VS Code and start typing.&lt;/p&gt;

&lt;p&gt;We spend weeks building a custom authentication system, a complex database schema, and a beautiful UI. We treat marketing as an afterthought — as if it's "spam" or something that "marketers do."&lt;/p&gt;

&lt;p&gt;But building a product without an audience is like building a microservice that nobody calls. It's just sitting there, consuming resources, doing nothing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Math of Distribution&lt;/strong&gt;&lt;br&gt;
Let's look at the math. If you build a product and tell nobody, your reach is 0.&lt;br&gt;
If you build a product and tell 10 people, maybe 1 person signs up.&lt;/p&gt;

&lt;p&gt;If you want 100 users, you don't need to refactor your codebase to be 10x faster. You need to reach 1,000 people.&lt;/p&gt;

&lt;p&gt;Marketing for developers isn't about spamming Twitter. It's about &lt;strong&gt;showing your work and explaining the architecture of the problem you solved.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Write about the bug you fixed.&lt;/strong&gt; People love a good debugging story.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Share your tech stack.&lt;/strong&gt; Explain why you chose Next.js over SvelteKit.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Talk about the failure.&lt;/strong&gt; Post-mortems get 10x more engagement than success stories.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Shift in Mindset&lt;/strong&gt;&lt;br&gt;
If you are building a side project this weekend, I challenge you to spend 30 minutes writing the code, and 30 minutes writing a post about why you are building it.&lt;/p&gt;

&lt;p&gt;If you're looking for a framework to actually launch your project and get it in front of people, I've packaged my exact launch strategy into a Dev Launch Kit. It's the checklist I wish I had when I was staring at my 0 visitors.&lt;/p&gt;

&lt;p&gt;Stop optimizing your package.json. Start optimizing your reach.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;What's your biggest struggle with launching side projects? Is it the code or the marketing? Let me know in the comments!&lt;/em&gt;&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>career</category>
      <category>sideprojects</category>
      <category>marketing</category>
    </item>
    <item>
      <title>Why I Treat My Personal Notion Templates Like a Database Schema</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Fri, 13 Nov 2026 07:17:50 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/why-i-treat-my-personal-notion-templates-like-a-database-schema-46eh</link>
      <guid>https://dev.to/alexcodebytes/why-i-treat-my-personal-notion-templates-like-a-database-schema-46eh</guid>
      <description>&lt;p&gt;As software engineers, we spend our days designing database schemas. We normalize tables, set up foreign keys, and obsess over data integrity. It’s beautiful, logical, and it works perfectly in production.&lt;/p&gt;

&lt;p&gt;So, naturally, when I started building my own productivity system in Notion, I applied the exact same logic. I created a relational masterpiece. I had a Tasks table with a relation to Projects, which was related to Areas of Life. I had rollups, formulas, and linked views.&lt;/p&gt;

&lt;p&gt;It looked like a well-architected microservice. It was also completely useless.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Problem with Over-Normalization&lt;/strong&gt;&lt;br&gt;
In databases, over-normalization leads to slow queries because you have to JOIN 10 tables just to get one piece of data.&lt;/p&gt;

&lt;p&gt;In productivity, over-normalization leads to decision fatigue. If I wanted to add a task like "Buy milk," I had to decide: Is this a project? Is it an area? What's the energy level? What's the priority?&lt;/p&gt;

&lt;p&gt;I was spending 15 minutes a day just doing data entry. My brain was spending more energy managing the system than actually doing the work. I was experiencing massive "cognitive load" just trying to open my dashboard.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Refactor: The Flat Table&lt;/strong&gt;&lt;br&gt;
I decided to refactor my entire system. I deleted all the relations and rollups.&lt;/p&gt;

&lt;p&gt;Now, my task manager is a single, flat table. It has only three columns:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Task Name&lt;/strong&gt; (String)&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Status&lt;/strong&gt; (Select: To Do, In Progress, Done)&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Date&lt;/strong&gt; (Date, optional)&lt;/p&gt;

&lt;p&gt;That's it. No complex JOIN logic. No dependencies.&lt;/p&gt;

&lt;p&gt;If I need context, I just write it in the task name (e.g., "Buy milk for Project X"). I use a simple filter: Status != Done. When a task is checked off, it disappears from my view.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why This Works Better Than Relational Databases&lt;/strong&gt;&lt;br&gt;
&lt;strong&gt;Low Friction:&lt;/strong&gt; Adding a task takes 2 seconds.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;No Dependency Hell:&lt;/strong&gt; If I don't update my "Life Areas" database, my daily task list still works perfectly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Mental Clarity:&lt;/strong&gt; A flat list is easy to scan. A relational dashboard requires cognitive parsing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Lesson&lt;/strong&gt;&lt;br&gt;
We love building complex systems because it makes us feel like good engineers. But good engineering is about solving a problem with the least amount of complexity necessary. Your personal life doesn't need a relational database. It needs a list.&lt;/p&gt;

&lt;p&gt;If you want to see how I structure this minimalist approach (with a few clever formulas for prioritization), I’ve shared my exact schema in the &lt;strong&gt;ADHD Daily Planner&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;How do you structure your tasks? Are you a relational database person or a flat list person? Let me know!&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>productivity</category>
      <category>architecture</category>
      <category>notionchallenge</category>
    </item>
    <item>
      <title>500 programmatic SEO pages and 11 APIs in 26 days. Here is the boring infrastructure that made it work.</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Tue, 10 Nov 2026 10:15:53 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/i-built-500-programmatic-seo-pages-and-11-apis-in-26-days-here-is-the-boring-infrastructure-that-52id</link>
      <guid>https://dev.to/alexcodebytes/i-built-500-programmatic-seo-pages-and-11-apis-in-26-days-here-is-the-boring-infrastructure-that-52id</guid>
      <description>&lt;p&gt;I spent the last 26 days building what I call &lt;strong&gt;boring-saas-infra&lt;/strong&gt;. Not a flashy AI wrapper. Not another no-code tool. Just the unglamorous plumbing every SaaS eventually needs: compliance checks, HS code classification, document parsing, finance validators, and watch engines.&lt;/p&gt;

&lt;p&gt;Here is what actually shipped, what broke, and why the boring parts matter.&lt;/p&gt;

&lt;h2&gt;
  
  
  The numbers first
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;500 programmatic pages&lt;/strong&gt; generated from a single &lt;code&gt;generator.js&lt;/code&gt; script. Each page solves a tiny, specific problem (e.g., “HS code for laptop” → 8471.30).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;11 APIs&lt;/strong&gt; running on Cloudflare Workers. Some are REST. Two are MCP servers for AI agents.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;200 URLs/day&lt;/strong&gt; pushed to Google Indexing API. The script tracks progress in &lt;code&gt;sent_urls.txt&lt;/code&gt; so it resumes exactly where it stopped.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;1 SPA 404 bug&lt;/strong&gt; fixed by switching to static output and a proper &lt;code&gt;404.html&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CI/CD&lt;/strong&gt; that deploys on every &lt;code&gt;git push&lt;/code&gt; to Cloudflare Pages.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Why programmatic SEO works when you stop overthinking it
&lt;/h2&gt;

&lt;p&gt;I did not write 500 articles by hand. I wrote three templates. Then I fed them a list of products and a mapping to HS codes.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;node generator.js&lt;/code&gt; outputs:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;500 static HTML pages&lt;/li&gt;
&lt;li&gt;A fresh &lt;code&gt;sitemap.xml&lt;/code&gt; with 514 URLs&lt;/li&gt;
&lt;li&gt;Redirects and headers for Cloudflare&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The entire SEO layer is a build step. No CMS. No database queries on the edge. Just static files.&lt;/p&gt;

&lt;p&gt;The lesson: &lt;strong&gt;if you can describe the page with a template and a data row, you can generate it.&lt;/strong&gt; The hard part is not the code. The hard part is deciding which 500 pages are worth generating.&lt;/p&gt;

&lt;h2&gt;
  
  
  The boring infrastructure that actually moved the needle
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Google Indexing API (and respecting the 200/day quota)
&lt;/h3&gt;

&lt;p&gt;I wrote a small Node script (&lt;code&gt;index-api.cjs&lt;/code&gt;) that reads &lt;code&gt;sitemap.xml&lt;/code&gt;, checks which URLs have already been sent, and pushes the next batch to Google’s Indexing API.&lt;/p&gt;

&lt;p&gt;When it hits the 200/day limit, it stops cleanly and writes the progress to a text file. The next day, it picks up where it left off.&lt;/p&gt;

&lt;p&gt;No fancy queue. No serverless cron. Just a file and a &lt;code&gt;while&lt;/code&gt; loop.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Suby for monetization (without building a billing system)
&lt;/h3&gt;

&lt;p&gt;I did not want to integrate Stripe, handle tax, and build a customer portal. Suby gave me checkout links in minutes.&lt;/p&gt;

&lt;p&gt;The site now embeds Suby checkout URLs for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Finance Tools Pro&lt;/strong&gt; ($19.99/month)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Compliance Suite&lt;/strong&gt; ($99/month)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;PEP Database CSV&lt;/strong&gt; (coming soon)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Each link is just an &lt;code&gt;&amp;lt;a href="..."&amp;gt;&lt;/code&gt;. No SDK. No webhook handling. If you are a solo developer, this is the fastest path from “useful API” to “someone can pay you.”&lt;/p&gt;

&lt;h3&gt;
  
  
  3. MCP servers for AI agents
&lt;/h3&gt;

&lt;p&gt;Two of the APIs are also exposed as &lt;strong&gt;MCP servers&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;document-to-json-mcp&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;watch-engine-mcp&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Agents can discover them in marketplaces and call them without an API key. For a small infra project, this is a distribution channel that did not exist two years ago.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I would do differently
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Do not automate the browser if you can automate the API.&lt;/strong&gt; I wasted hours trying to scrape a dashboard with Puppeteer. The API (and a canonical URL) was the right answer.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fix the canonical URL before you syndicate.&lt;/strong&gt; If you cross-post without &lt;code&gt;canonical_url&lt;/code&gt;, Dev.to and Medium will outrank your own domain[reference:1]. This is not optional.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship the boring things first.&lt;/strong&gt; The 404 page, the sitemap, the deploy script, the &lt;code&gt;llms.txt&lt;/code&gt; file — these do not feel like “product,” but they are what makes the product findable.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What is next
&lt;/h2&gt;

&lt;p&gt;Day 27–29 is distribution: Dev.to, Medium, X, and AI directories. If you are building something boring but useful, the distribution is the hard part. The code is the easy part.&lt;/p&gt;

&lt;p&gt;The site is live at &lt;a href="https://boring-saas-infra.pages.dev" rel="noopener noreferrer"&gt;boring-saas-infra.pages.dev&lt;/a&gt;. If you want to see the generated pages, start with the &lt;a href="https://boring-saas-infra.pages.dev/catalog/" rel="noopener noreferrer"&gt;HS code catalog&lt;/a&gt;.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://boring-saas-infra.pages.dev/" rel="noopener noreferrer"&gt;boring-saas-infra.pages.dev&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>api</category>
      <category>seo</category>
      <category>buildinpublic</category>
    </item>
    <item>
      <title>Your Side Project Doesn't Need a Security Team (But It Does Need a Checklist)</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Mon, 09 Nov 2026 04:26:56 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/your-side-project-doesnt-need-a-security-team-but-it-does-need-a-checklist-m4a</link>
      <guid>https://dev.to/alexcodebytes/your-side-project-doesnt-need-a-security-team-but-it-does-need-a-checklist-m4a</guid>
      <description>&lt;p&gt;I used to think that security was something only big enterprises needed to worry about. "Who's going to hack my little side project?" I'd tell myself. "I'm just building a simple SaaS for 10 users."&lt;/p&gt;

&lt;p&gt;Then I saw a post on Reddit from a developer whose indie project got hit by a botnet. The attacker found a single unprotected API endpoint, exploited a simple IDOR (Insecure Direct Object Reference) vulnerability, and wiped his entire database.&lt;/p&gt;

&lt;p&gt;That’s the thing about the internet: nobody cares how small you are. Automated scanners run 24/7, looking for open S3 buckets, exposed .env files, and missing authentication headers. If your app is public, you are a target.&lt;/p&gt;

&lt;p&gt;I spent the next few weeks learning about web security. I didn't want to become a security expert — I just wanted to ensure my side projects weren't an easy target.&lt;/p&gt;

&lt;p&gt;Here is the exact checklist I now use before deploying any side project to production.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Authentication &amp;amp; Authorization
The most common bug in side projects is confusing authentication with authorization.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Authentication: Who are you?&lt;/p&gt;

&lt;p&gt;Authorization: Are you allowed to see this?&lt;/p&gt;

&lt;p&gt;I cannot tell you how many times I've seen an API endpoint like GET /api/user/123 where 123 is just the user ID. If you change 123 to 124, you can see another user's data. This is called IDOR.&lt;/p&gt;

&lt;p&gt;The Fix: Never trust the client. If a user requests /api/invoices/123, your backend must verify that the authenticated user actually owns invoice 123. Use UUIDs instead of sequential IDs to make it harder for attackers to guess.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The .env File (The Silent Killer)
As developers, we love open-source. But we often push our .env files to public GitHub repositories by accident. If your database credentials, API keys, or JWT secrets are exposed, your app is essentially a public frontend.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The Fix:&lt;/p&gt;

&lt;p&gt;Add .env to your .gitignore file (do this immediately).&lt;/p&gt;

&lt;p&gt;Use a tool like git-secrets or GitHub's secret scanning to prevent committing keys by accident.&lt;/p&gt;

&lt;p&gt;Rotate your keys if you suspect they've been leaked. Don't just delete the commit — the data is already out there.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Rate Limiting (Why You Need It)
If you have an API, you need rate limiting. Without it, a bot can brute-force your login page or spam your signup form, causing resource exhaustion or spamming your database.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The Fix: Use a middleware like express-rate-limit for Node.js, or use a service like Cloudflare or Upstash to rate limit requests at the edge. A simple rule like "100 requests per 15 minutes per IP" will stop 99% of automated abuse.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Password Hygiene
If you're building an app, you're likely dealing with passwords. If you're storing passwords in plain text, stop what you're doing and fix it immediately.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The Fix: Use a strong hashing algorithm like bcrypt or argon2. Never write your own cryptography.&lt;/p&gt;

&lt;p&gt;But the real security win comes from the user side. If you run any kind of SaaS, consider implementing 2FA (Two-Factor Authentication). It’s the single most effective way to prevent account takeovers.&lt;/p&gt;

&lt;p&gt;I’ve actually built a Password Playbook that documents the exact steps for securing accounts in 30 minutes—it's great to share with your users or keep for yourself.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Never Trust User Input
SQL Injection (SQLi) and Cross-Site Scripting (XSS) are still two of the most common vulnerabilities in web apps. If you're using an ORM like Prisma or Drizzle, most of these attacks are mitigated. But if you're writing raw SQL, you must use parameterized queries.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The Fix:&lt;/p&gt;

&lt;p&gt;Sanitize and validate all incoming data using a library like zod or joi.&lt;/p&gt;

&lt;p&gt;Use parameterized queries.&lt;/p&gt;

&lt;p&gt;Set up a strict Content Security Policy (CSP) to prevent XSS.&lt;/p&gt;

&lt;p&gt;The Pre-Deploy Checklist&lt;br&gt;
Before you run npm run build and push to production, run through this checklist:&lt;/p&gt;

&lt;p&gt;Authentication: Are all endpoints protected?&lt;/p&gt;

&lt;p&gt;Authorization: Does every route verify ownership (IDOR)?&lt;/p&gt;

&lt;p&gt;Input Validation: Is every request body validated with a schema?&lt;/p&gt;

&lt;p&gt;Secrets: Is .env in .gitignore? Are there any hardcoded API keys?&lt;/p&gt;

&lt;p&gt;Rate Limiting: Are your routes protected against spam?&lt;/p&gt;

&lt;p&gt;Passwords: Are they hashed with bcrypt?&lt;/p&gt;

&lt;p&gt;If you want the exact technical checklist I use for my own side projects, I’ve compiled it into an API Security Checklist. It walks through every endpoint, header, and token.&lt;/p&gt;

&lt;p&gt;Stay safe out there.&lt;/p&gt;

&lt;p&gt;Have you ever been hacked? What’s the biggest security mistake you’ve made in a side project? Let’s share our war stories in the comments!&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>programming</category>
      <category>security</category>
      <category>showdev</category>
    </item>
    <item>
      <title>The End of Boilerplate: How AI is Changing the Way We Build Side Projects</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Sat, 07 Nov 2026 04:29:14 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/the-end-of-boilerplate-how-ai-is-changing-the-way-we-build-side-projects-3im5</link>
      <guid>https://dev.to/alexcodebytes/the-end-of-boilerplate-how-ai-is-changing-the-way-we-build-side-projects-3im5</guid>
      <description>&lt;p&gt;Remember the "good old days" of starting a new side project?&lt;/p&gt;

&lt;p&gt;You’d spend the first weekend just setting up the environment. You’d configure Webpack (or Vite), set up ESLint and Prettier, wire up a basic CI/CD pipeline, configure the ORM, and write the initial folder structure. By the time you actually wrote a line of feature code, your motivation was already at 20%.&lt;/p&gt;

&lt;p&gt;We called it "boilerplate fatigue."&lt;/p&gt;

&lt;p&gt;Fast forward to today. I can open ChatGPT, paste a prompt like "Generate a Next.js 14 boilerplate with Tailwind, Prisma, and NextAuth," and within 30 seconds, I have a fully functioning repository.&lt;/p&gt;

&lt;p&gt;AI has fundamentally changed the way we start projects. But it’s also changed the skills we need to be successful.&lt;/p&gt;

&lt;p&gt;The Shift from "Typing" to "Architecting"&lt;br&gt;
When AI can write your boilerplate, your API routes, and your basic CRUD operations, the bottleneck is no longer typing speed. The bottleneck becomes system design.&lt;/p&gt;

&lt;p&gt;If I don't know how to structure my database, AI will just guess (and often guess wrong). If I don't understand the difference between Server Components and Client Components in React, the AI will generate a mess of hydration errors that I won't know how to debug.&lt;/p&gt;

&lt;p&gt;AI doesn't replace the need for fundamental knowledge; it amplifies it. It allows you to skip the boring parts, but you still need to know how the engine works to drive the car.&lt;/p&gt;

&lt;p&gt;The New Side Project Workflow&lt;br&gt;
Here is how I build side projects now:&lt;/p&gt;

&lt;p&gt;Design the Schema First: Before touching any AI tool, I design the database schema and the core user flow. If the foundation is wrong, the generated code will be a house of cards.&lt;/p&gt;

&lt;p&gt;Generate the Scaffolding: I use AI to generate the initial scaffolding, UI components, and basic API routes. (I keep a vault of AI prompts specifically for developers to get the best output).&lt;/p&gt;

&lt;p&gt;Review and Refactor: AI code is often "smelly." It works, but it might not be efficient or scalable. I spend my time reviewing the generated code rather than writing it from scratch.&lt;/p&gt;

&lt;p&gt;Ship Fast: Because the boilerplate is done in hours instead of weeks, I can actually get to the deployment phase in a single weekend.&lt;/p&gt;

&lt;p&gt;The Danger of Over-reliance&lt;br&gt;
The biggest trap developers fall into right now is accepting AI-generated code blindly.&lt;/p&gt;

&lt;p&gt;I recently asked an AI to write a complex SQL query. It wrote a beautiful, perfectly formatted query — that used a deprecated syntax and would have locked up the database under heavy load. Because I understood the underlying SQL, I caught it. A junior developer might have pushed it to production.&lt;/p&gt;

&lt;p&gt;Use AI as a junior developer. It’s great for writing the repetitive stuff, but you are the senior. You are the one who signs off on the pull request.&lt;/p&gt;

&lt;p&gt;What's Next?&lt;br&gt;
We are entering an era where the barrier to entry for building software is lower than ever. But the barrier to building good software is still just as high.&lt;/p&gt;

&lt;p&gt;If you are starting a new project this weekend, don't spend hours tweaking your ESLint config. Prompt the AI, generate the base, and focus on the features that actually matter.&lt;/p&gt;

&lt;p&gt;If you want to launch your next side project but hate setting up the boring infrastructure, I've packaged my exact step-by-step checklist, Notion workspace, and deployment guide into a Dev Launch Kit. It goes from zero to deployed in a single evening.&lt;/p&gt;

&lt;p&gt;And if you want to get the most out of your AI coding assistant, check out the AI Prompt Vault — it has over 500 prompts specifically tailored for developers.&lt;/p&gt;

&lt;p&gt;What's your take? Do you use AI for boilerplate, or do you prefer to write it yourself? Let me know in the comments!&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>productivity</category>
      <category>programming</category>
    </item>
    <item>
      <title>Why Your Side Project Dies on Localhost (And How to Actually Ship It)</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Fri, 06 Nov 2026 04:31:22 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/why-your-side-project-dies-on-localhost-and-how-to-actually-ship-it-4044</link>
      <guid>https://dev.to/alexcodebytes/why-your-side-project-dies-on-localhost-and-how-to-actually-ship-it-4044</guid>
      <description>&lt;p&gt;Every developer has a graveyard of unfinished side projects.&lt;/p&gt;

&lt;p&gt;You know the ones. The brilliant SaaS idea you had at 2 AM. The Chrome extension that was going to change your life. The portfolio site you started to rebuild for the third time because you wanted to try out that new React framework.&lt;/p&gt;

&lt;p&gt;You spend weeks in "Tutorial Hell," watching 10-hour YouTube videos, setting up the perfect boilerplate, configuring ESLint, and writing a bulletproof CI/CD pipeline.&lt;/p&gt;

&lt;p&gt;And then... you run npm run dev one last time, look at your localhost, and close the terminal. The project never sees the light of production.&lt;/p&gt;

&lt;p&gt;Why does this happen? And more importantly, how do you break the cycle?&lt;/p&gt;

&lt;p&gt;Here is what I learned after leaving dozens of projects to rot in my local C:\Users\dev\projects folder.&lt;/p&gt;

&lt;p&gt;The Trap of "Learning by Building"&lt;br&gt;
We are told that the best way to learn is to build. So we start a project to learn a new stack.&lt;/p&gt;

&lt;p&gt;But there is a massive difference between building to learn and learning to ship.&lt;/p&gt;

&lt;p&gt;When you build to learn, the goal is to write the most technically perfect code. You refactor constantly. You add state management libraries you don't need. You spend three days configuring a custom Webpack setup just because you can.&lt;/p&gt;

&lt;p&gt;When you learn to ship, the goal is to get it into the hands of users. And users don't care about your Webpack config. They care about whether your app solves their problem.&lt;/p&gt;

&lt;p&gt;The 3-Step Launch Checklist&lt;br&gt;
If you want to actually ship your next side project, you need to apply the MVP (Minimum Viable Product) mindset.&lt;/p&gt;

&lt;p&gt;Here is the exact checklist I use to force myself to launch:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Set a Hard Deadline (and tell people)&lt;br&gt;
Nothing kills a project faster than "I'll finish it when it's ready." It will never be ready.&lt;br&gt;
Pick a date two weeks from today and announce it to the world. Tell your friends, tell your Twitter followers. The fear of public embarrassment is a powerful motivator.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Cut 50% of Your Features&lt;br&gt;
Look at your feature list. Now cross out half of them.&lt;br&gt;
Do you need user authentication for an MVP? No, use a simple magic link. Do you need a custom admin dashboard? No, use Airtable. Do you need a subscription model on day one? No, use a simple checkout link (like Stripe or Lemon Squeezy).&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Your only goal is to prove that the core loop works.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Deploy on Day One
Don't wait until your code is "clean" to deploy.
On the very first day of your project, buy the domain, set up the hosting (Vercel, Netlify, or Cloudflare Pages), and push a "Coming Soon" page. Then, deploy every single time you make a commit.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Seeing your project live on the internet changes your psychology. It stops being a "hobby" and becomes a "product."&lt;/p&gt;

&lt;p&gt;The "Post-Launch" Reality&lt;br&gt;
Here is the secret no one tells you: Launching is the easy part.&lt;/p&gt;

&lt;p&gt;Once you ship, you will realize that nobody uses your app. You will get zero traffic. And that's completely normal. The real work isn't the code; it's the distribution.&lt;/p&gt;

&lt;p&gt;But if you never launch, you can't iterate. You can't get feedback. You can't improve.&lt;/p&gt;

&lt;p&gt;What I Use to Ship Faster&lt;br&gt;
Over the years, I've optimized my "Launch Stack." I use Cloudflare for hosting, Notion for my content calendar, and Suby for quick payments.&lt;/p&gt;

&lt;p&gt;If you are tired of writing the same boilerplate code and just want to get your idea out the door, I've put together a Dev Launch Kit. It includes my exact launch checklist, a Notion template for tracking your progress, and a guide on how to go from localhost to a live URL in a single evening.&lt;/p&gt;

&lt;p&gt;If you are looking to turn your side project into actual income, check out the Side Hustle Starter Pack. It has the frameworks I use to validate an idea before writing a single line of code.&lt;/p&gt;

&lt;p&gt;Stop tweaking your package.json. Buy the domain. Deploy the app. Ship the project.&lt;/p&gt;

&lt;p&gt;Your future self will thank you.&lt;/p&gt;

&lt;p&gt;Have you ever launched a side project? What was the hardest part about actually shipping it? Let me know in the comments!&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>sideprojects</category>
      <category>career</category>
      <category>productivity</category>
    </item>
    <item>
      <title>I Applied Agile to My Personal Life. It Almost Burned Me Out.</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Thu, 05 Nov 2026 07:21:38 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/i-applied-agile-to-my-personal-life-it-almost-burned-me-out-335c</link>
      <guid>https://dev.to/alexcodebytes/i-applied-agile-to-my-personal-life-it-almost-burned-me-out-335c</guid>
      <description>&lt;p&gt;As software engineers, our brains are wired for systems. We love order, optimization, and clear workflows. So, a few years ago, I had what I thought was a genius idea: Why not apply Agile methodologies to my personal life?&lt;/p&gt;

&lt;p&gt;If it works for shipping enterprise software, it should work for shipping personal goals, right?&lt;/p&gt;

&lt;p&gt;I set up a "Personal Scrum" board. I created a backlog for my life. I broke down my goals into epics, and those epics into user stories. I even held a weekly "retrospective" with myself to identify blockers in my personal life.&lt;/p&gt;

&lt;p&gt;It was the most miserable I have ever been.&lt;/p&gt;

&lt;p&gt;Here is why applying software engineering principles to your personal life is a trap, and how I fixed it.&lt;/p&gt;

&lt;p&gt;The Trap of "Life Technical Debt"&lt;br&gt;
When you treat your life like a software project, you start to view normal human experiences as inefficiencies.&lt;/p&gt;

&lt;p&gt;Resting becomes "downtime."&lt;/p&gt;

&lt;p&gt;Hobbies become "side quests."&lt;/p&gt;

&lt;p&gt;Unfinished books become "technical debt."&lt;/p&gt;

&lt;p&gt;I had a Notion dashboard with 47 interconnected databases. I had tags for context, energy levels, and priority. Every time I wanted to do something as simple as "Go for a walk," I had to decide which project it fell under, log it, and check it off.&lt;/p&gt;

&lt;p&gt;I was spending more time managing my life than actually living it.&lt;/p&gt;

&lt;p&gt;The MVP Mindset Went Wrong&lt;br&gt;
In software, we build an MVP (Minimum Viable Product) to test a hypothesis. But in life, I was trying to build an MVP for my entire existence. I was optimizing for "velocity" instead of "value."&lt;/p&gt;

&lt;p&gt;I realized that the human brain doesn't have an API. You can't just scale up your energy levels by adding more coffee and pushing a sprint.&lt;/p&gt;

&lt;p&gt;When you introduce high friction into your personal workflow, your brain (the CPU) eventually hits 100% utilization and simply crashes. That's called burnout.&lt;/p&gt;

&lt;p&gt;The Refactor: Radical Simplicity&lt;br&gt;
I decided to deprecate the "Life Scrum" system. I deleted all the databases. I threw away the epics and the user stories.&lt;/p&gt;

&lt;p&gt;I replaced it with a system that has only one rule: The 3-Task Rule.&lt;/p&gt;

&lt;p&gt;Every morning, I write down exactly three things I want to accomplish that day. It doesn't matter if they are work-related, personal, or just "take a nap." Those are my three priorities.&lt;/p&gt;

&lt;p&gt;I don't track them in 5 different places. I don't assign them story points. I just do them.&lt;/p&gt;

&lt;p&gt;Here is the "architecture" of my new system:&lt;br&gt;
Today:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;[ ] Write one section of the new API docs&lt;/li&gt;
&lt;li&gt;[ ] Go to the gym&lt;/li&gt;
&lt;li&gt;[ ] Cook dinner instead of ordering
That's it. No dependencies. No blockers. No velocity charts.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;What I Learned&lt;br&gt;
Friction is the enemy of execution. If your productivity system takes more than 10 seconds to open and understand, you will abandon it.&lt;/p&gt;

&lt;p&gt;Not everything needs to be a system. Your life is not a Jira board. Some things are just things you do because you're a human being.&lt;/p&gt;

&lt;p&gt;Optimize for peace, not just output. A system that helps you ship code but gives you an anxiety attack is a bad system.&lt;/p&gt;

&lt;p&gt;The Result&lt;br&gt;
By removing the heavy Agile framework from my personal life, I actually got more done. I stopped procrastinating because I wasn't overwhelmed by a massive backlog of "life tasks."&lt;/p&gt;

&lt;p&gt;If you are a developer who feels burned out by your own productivity system, try deleting it. Strip it down to a flat list of three tasks. See how it feels to have a "boring" system.&lt;/p&gt;

&lt;p&gt;I eventually got tired of rebuilding my task list from scratch every day, so I built a super minimal Notion template that implements this exact 3-Task philosophy. It has no flashy dashboards, just a clean space to focus on what matters. You can check out the ADHD Daily Planner here.&lt;/p&gt;

&lt;p&gt;If you want to read more about why over-engineered Notion templates fail, I wrote about it on my blog here.&lt;/p&gt;

</description>
      <category>productivity</category>
      <category>career</category>
      <category>mentalhealth</category>
      <category>agile</category>
    </item>
    <item>
      <title>How I Automated My Entire Freelance Workflow (And Saved 10 Hours a Week)</title>
      <dc:creator>Oleksandr</dc:creator>
      <pubDate>Tue, 03 Nov 2026 15:37:28 +0000</pubDate>
      <link>https://dev.to/alexcodebytes/how-i-automated-my-entire-freelance-workflow-and-saved-10-hours-a-week-4ahh</link>
      <guid>https://dev.to/alexcodebytes/how-i-automated-my-entire-freelance-workflow-and-saved-10-hours-a-week-4ahh</guid>
      <description>&lt;p&gt;When you start freelancing as a developer, you think your job is 100% writing code.&lt;/p&gt;

&lt;p&gt;But the reality is much different. Freelancing is 40% coding, and 60% admin. You have to find clients, send proposals, write contracts, track invoices, chase late payments, and manage project timelines.&lt;/p&gt;

&lt;p&gt;If you don't automate the admin work, it will eat into your billable hours and lead to burnout. As developers, we automate our servers and our CI/CD pipelines. We should be automating our business operations too.&lt;/p&gt;

&lt;p&gt;Here is the exact stack and workflow I built to automate my freelance business, so I can focus purely on writing code.&lt;/p&gt;

&lt;p&gt;The Stack&lt;br&gt;
Notion: The central hub for all client data, projects, and invoices.&lt;/p&gt;

&lt;p&gt;Zapier (or Make): The glue that connects all the apps.&lt;/p&gt;

&lt;p&gt;Stripe (or Suby/Paddle): To handle the actual payments.&lt;/p&gt;

&lt;p&gt;Calendly: For booking discovery calls without endless email ping-pong.&lt;/p&gt;

&lt;p&gt;The Workflow: Step-by-Step&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Client Intake (The Lead Generation)&lt;br&gt;
I use a simple form (Tally or Typeform) on my website. When a potential client fills it out, Zapier automatically creates a new card in my "Leads" Notion database. It also sends an automated email to the client with a link to my Calendly, so they can book a discovery call immediately.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Proposals and Contracts (The Legal Side)&lt;br&gt;
Once a client is ready to move forward, I don't waste time writing a custom proposal from scratch. I use a pre-made Notion template for my proposals. I share the page with them. It contains the scope of work, the timeline, and the pricing.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Pro-tip: For the contract and NDA, never write them from scratch. Use pre-built templates that have been vetted by a lawyer. I use a Contract &amp;amp; NDA Pack that covers 99% of freelance scenarios. It saves me hundreds of dollars in legal fees.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Invoicing and Payments (The Money)
This is where most freelancers waste time. I used to manually generate PDF invoices and send them via email, then set calendar reminders to follow up.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Now, I generate a payment link using Stripe. When the client pays, Zapier listens for the checkout.session.completed webhook. Once triggered, it updates the invoice status in Notion to "Paid" and marks the project as "Active."&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Project Kickoff
As soon as the payment clears, Zapier automatically creates a shared Slack channel (or a shared Notion workspace) for the client, invites the client, and sends them a welcome message with an onboarding questionnaire.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;No manual setup. No "Hey, I just sent the invite" emails. It just happens.&lt;/p&gt;

&lt;p&gt;The ROI of Automation&lt;br&gt;
It took me about a weekend to set up these automations. But now, I save roughly 10 hours every single week that I used to spend on admin, copy-pasting data, and writing invoices. That’s 10 extra hours of billable coding time.&lt;/p&gt;

&lt;p&gt;If you are a freelancer, look at your workflow this week. Find the most repetitive task (like sending invoices) and automate it. Your future self will thank you.&lt;/p&gt;

&lt;p&gt;If you want to skip the setup phase and just grab the exact recipes I use, I have a Zapier Automation Recipes pack here that includes all the triggers and actions.&lt;/p&gt;

&lt;p&gt;And if you want to streamline your client experience from day one, check out the Client Onboarding System.&lt;/p&gt;

</description>
      <category>freelance</category>
      <category>automation</category>
      <category>zap</category>
      <category>notionchallenge</category>
    </item>
  </channel>
</rss>
