You built the app with AI. Now it has to run in production. Working on a laptop is not the same as staying up on a server: DNS, HTTPS, process supervision, database permissions, logs, backups, release rollback — miss one and the first incident takes back all the time the AI saved you.
We take over the runtime side after launch. We do not rewrite your application code; we own the deployment, security baseline, monitoring, backups and incident response needed to keep it running.
Who this is for
You shipped code with AI, but not to a server
Cursor, Claude Code, Lovable and similar tools produce a working project quickly. Getting it onto a server — DNS, certificates, reverse proxy, process supervision — is a different skill set, and the first deploy usually fails.
You have a developer, not an operations team
Someone can write the code, but nobody owns servers, backups, monitoring or hardening. When something breaks, the first move is a restart, and there is no second move.
The contractor left, the environment stayed
The project was delivered, the developer moved on, and the server keeps a configuration nobody dares to touch. OS upgrades, certificate renewal and database growth are all hanging.
It is live, but unmonitored and unbacked
“It loads” is treated as stable. Failures are usually reported by users, and the database has never been through a real restore drill.
The cloud bill makes no sense
Model calls, object storage, bandwidth and snapshots each bill separately. No one knows where the money goes, or whether someone is abusing the API.
You must hand over a verifiable checklist
Clients ask for pre-launch security checks, a backup plan and an escalation contact. Assembling that document ad hoc costs time and always misses something.
What we take over
| Layer | What we do |
|---|---|
| Deployment | Node.js / Python / Go / PHP apps, decoupled front-ends, mini-program backends; Nginx reverse proxy, HTTPS, process supervision (systemd / PM2 / Docker), start on boot |
| Runtime | OS and runtime versions, dependency pinning, centralized secrets and environment variables, MySQL / PostgreSQL / Redis setup and least-privilege accounts |
| Security | SSH hardening, port reduction, firewall, WAF and rate limiting, no leaked keys, log redaction; an exposure check before go-live |
| Observability | Access and error log collection, process and port liveness probes, CPU / memory / disk / bandwidth thresholds, model spend and usage alerts |
| Data | Scheduled database backups, file and config backups, off-site or object-storage retention, periodic restore drills — an untested backup is not a backup |
| Release & rollback | A release process, change log, pre-built rollback command and agreed maintenance windows; a bad release goes back in minutes |
| Cost control | Pay-as-you-go watch, idle resource cleanup, rate limits and timeouts so a retry storm cannot turn into an invoice incident |
Go-live checklist
Going live is not “the page loads”. This is the acceptance list we deliver against, item by item:
- Domain and HTTPS
DNS resolving, full certificate chain, working auto-renewal; apex and www normalized to one canonical host.
- Process supervision
Automatic restart on crash, automatic start after reboot — no manual login required.
- Reverse proxy and static assets
Nginx rules, compression and cache headers, upload limits and timeouts matched to real usage.
- Secrets and configuration
Keys, database passwords and third-party API keys live in environment variables or config files, never in code or the front-end.
- Database
Dedicated account, least privilege, internal network only; connection and slow-query baselines recorded.
- Firewall
Only required ports open; admin surfaces kept off the public internet or protected by MFA and source restrictions.
- Logs
Application and access logs on disk, rotated by size, retained long enough to investigate history.
- Alerts
Process, port, disk and memory alerts routed to a person, with thresholds set for your peak load rather than defaults.
- Backups
Daily automated backups with multiple generations; one real restore drill completed and documented before handover.
- Rollback
A one-command rollback script plus the previous working build; release notes describing what changed.
- Cost watch
Inventory of on-demand and committed resources, alert thresholds, and a list of idle items that can be cleaned up.
- Handover document
One page: architecture, entry points, common commands, backup locations, escalation contacts and upgrade path.
Where AI-written code breaks in production
None of these are about code style. Most are invisible in a local demo and get amplified the moment real traffic arrives:
| Symptom | Impact | What we do |
|---|---|---|
| API keys in front-end code or committed to the repo | Scraped and used to burn your model quota and storage budget | Full-repo scan before launch, move to server-side env vars, revoke and reissue anything already exposed |
| No authentication on endpoints, or checks only in the browser | Anyone can call the backend directly and read or write other users’ data | Review auth and authorization on every endpoint, add a second check on admin-style actions |
| Dependencies pinned to “latest” | An automatic upgrade breaks the service and nobody knows which version to return to | Pin versions, keep lock files, test upgrades in staging first |
| No defense against prompt injection | The model is tricked into calling tools or reading data it should not reach | Allow-list tool calls, enforce permission boundaries, require human confirmation for sensitive actions |
| Unbounded retries and loops | One upstream hiccup triggers infinite retries and the bill doubles by the hour | Cap retries, timeouts, concurrency and daily budget; alert and trip a circuit breaker |
How we support it
Coverage and response
Weekdays 10:00–22:00 (UTC+8) online, 7×24 emergency response. Tickets go directly to the engineer, not a queue or a reseller.
Change trail
Every change records what was done, why, and how to roll it back. When something breaks, the change log is the fastest lead.
Check first, quote second
A free assessment before takeover: current state, risks, whether backups actually restore. A written issue list within one business day.
No lock-in
Documentation and configuration stay yours. Moving to in-house ops or another provider needs no permission or “unlock” from us.
Pricing models
Three models, chosen by project size and whether you need ongoing coverage. Exact pricing follows the assessment and is quoted against real workload — we do not publish a blanket “starting from” number.
| Model | Best for | Includes |
|---|---|---|
| Project go-live package | A single launch, then you take over | Deployment, security baseline, monitoring and backup setup, item-by-item acceptance against the go-live checklist, handover document and a walkthrough |
| Monthly retainer | Smaller apps that need someone watching | Monthly inspection, backup verification, alert response, dependency and certificate updates, small changes on request |
| Per server, per year | Multiple servers needing long-term cover | Monitoring and alerting, incident response, hardening, backup strategy, quarterly review |
Model usage and cloud resource fees are billed by the provider on a pay-as-you-go basis and are not part of the operations fee. We estimate the order of magnitude during planning and configure spend alerts in monitoring.
Development vs. operations
| AI Application Development & Maintenance | AI App Hosting & Operations (this page) | |
|---|---|---|
| What it covers | Writing the app: requirements, model integration, prompts and retrieval, iteration | Running the app: servers, runtime, security, monitoring, backups, releases |
| Typical question | “Can AI do this, and how?” | “It is written — how do we ship it, and who owns it afterwards?” |
| Deliverable | A working application, code and documentation | A verified runtime and ongoing coverage |
| Can you pick only one? | Yes — we can work with code written elsewhere | Yes — we can take over the environment without touching your code |
FAQ
The code was written by AI and it is messy. Will you still take it?
Yes. We take over the runtime, not the code style. Before launch we run an exposure and configuration review, separating “will cause an incident” from “merely inelegant”, and fix the former first. Where code must change, we explain what, why and the risk — you or we can make the change.
Do I have to hand over the server?
No. We can deliver a plan and checklist for your team to apply, or operate remotely while the server and accounts stay in your name. Only per-server annual coverage requires standing access; credentials can be held by you and granted per procedure.
Does it work on Alibaba Cloud, Tencent Cloud, Huawei Cloud or AWS?
All of them, plus self-built data centers and IDC-hosted hardware. We are not tied to a provider; recommendations follow your workload and budget.
It is already running. Can you take over mid-flight?
Yes — that is the common case. The first step is an assessment: architecture, whether backups restore, monitoring coverage, certificate and domain expiry. Once risks are clear, we agree which layer to take over first.
Will you see my data and keys?
Operations requires server access; we will not pretend otherwise. Where it is controllable we do: keys held by you or granted temporarily, redacted logs, audited changes. If sensitive data must never leave your network, the model can be self-hosted so nothing reaches an external API.
Does the go-live package mean you disappear afterwards?
The package includes the handover document and a walkthrough so your team can run it. If you later want ongoing coverage, move to the monthly retainer or per-server plan — and either way the configuration is never opaque to you.