Render has published an essay on a question that sounds philosophical until an agent ships your code: when is something actually in production? The post, "What does "production" mean in the era of agentic development?" by Shifra Williams, carries a dateline of 17 November 2026 (we read it on 15 November 2026). Its answer is short, and we agree with it:
"At Render, we consider an application in production when users or other systems rely on it."
Not when it is deployed, and not when someone labels it GA. In their words: "That can happen before anyone formally deploys it to a production environment, just as an application can be deployed before anyone relies on it."
This is a companion to our earlier piece, Deploying From Claude Code: What to Check Before an Agent Ships to Your Host. That one is a checklist for the moment of shipping. This one is about what happens after: the point where people start depending on the thing, and somebody has to own it.
Why agents make the line harder to see
Render's argument is not that agent-written code is worse. It is that speed hides the gap between "it runs" and "people can rely on it":
"AI has not changed what people need from production software, but agentic development makes it easier to deploy an application before verifying that it can support users reliably."
The post is even-handed about it. It points out that an agent might harden an API endpoint where a human would take a shortcut, and still leave plain-text credentials in the version history. Its conclusion: "Sophistication in one area doesn't guarantee that the foundations are in place elsewhere."
The strongest passage is a worked example about an internal support app:
"A coding agent can build you an internal support app with an interface and a working connection to customer data in less than a day."
"But it can't tell you who can access that data, whether the credentials are protected, or who will maintain the app once it ships."
"If the support team starts relying on it, someone has to answer those questions and own the app, even if an agent wrote every line of code."
Three questions: access, credentials, maintenance. None of them is answered by the code, and none is answered by the host either. That is the part worth being precise about.
(The most quotable line in the post is not Render's own. It quotes an unnamed developer: "If no one depends on your code and nothing meaningful happens when it breaks, it's not yet production." It is a good test, and it is someone else's.)
What a host can take off your plate, and what it cannot
Render's essay also describes a tiered set of production requirements that its security engineering team developed for internally managed applications. That model is about Render's own internal apps, not a product, but the principle behind it travels: "The safeguards should reflect the risk your application carries: what could go wrong, how likely it is, and how much it would affect the people relying on it."
So here is the split on DeployBase, stated from how the platform actually works rather than how we would like it to sound.
What the platform does
- Keeps the process running. App containers are set to restart automatically if the process exits, so a crash at 3 a.m. comes back without anyone logging in.
- HTTPS. Certificates for your domains are issued and renewed automatically through Let's Encrypt.
- Shows whether scheduled jobs worked. Cron jobs you add in the dashboard show when they last ran, their exit code and how long they took, so a job that has been failing every minute is visible rather than silent.
- Keeps environment variables out of your repository. Variables you set in the dashboard are written to your app's own
.envfile on the server, and changing one restarts the app with the new value.
What stays yours, on any host
- Who can access the data. A DeployBase account has one login; there are no per-person team seats. If several people need the dashboard, they share that login, which is a reason to turn on two-factor authentication in Settings. It is opt-in, not on by default. Access inside your app (who can see customer records in that support tool) is entirely your code.
- Whether the credentials are protected. Moving a secret into an environment variable does not remove it from your Git history. If an agent ever committed a key, rotate the key; rewriting history alone is not enough, because clones and caches keep the old commits.
- Who maintains it. Dependency updates, framework upgrades and the agent-written code itself are yours. A restart policy brings a crashed process back. It does not fix the bug that crashed it.
- Where you test before users see it. If people rely on the app, changes should land somewhere that is not the thing they rely on. On DeployBase, staging environments are included from the Business plan up; Starter and Pro do not include one.
- Who hears about it when it breaks. Decide this before the first incident, not during it.
Git deploys and SSH access start at the Pro plan; Starter has neither. That matters here because "how does a fix get from the agent to the server" is part of maintenance, and the answer differs by plan.
Production is a practice, not a status
The line from Render's essay that holds up best is this one: "Production readiness is less an earned status than a set of practices to maintain." No host makes an application production-ready, including us. What a host can do is take the undifferentiated parts off your list, so the questions that are actually yours (access, credentials, maintenance, who gets paged) are the ones you spend time on.
If an agent built something last week and your team started using it this week, it is in production by Render's definition and by ours. The useful next step is not another feature. It is answering those questions, and writing down who owns the app.
Source, read 15 November 2026: Render, "What does "production" mean in the era of agentic development?" (dateline 17 November 2026).