Turnkey AI plugin development for WordPress: from REST API to chat widget

Why the AI plugin for WordPress breaks under real load

In a demo, the plugin responds in a second, but on a live site, model response timeout becomes a standard scenario. Generation starts right in the request handler: while the model is computing, the handler process is busy and does not serve the page.

With several concurrent authors, available handlers run out before the first response arrives — the site stops loading, and this is already an availability issue, not a text quality issue.

The second source of failures is duplicate requests. Draft autosave, returning to the tab, retry after a network error: each time a new call is made, although the result is visually the same.

Under load on the AI plugin, this creates a queue, hitting rate limits, and consumption that grows without connection to the editorial team's actual work.

A separate issue is access key leakage. The key sits in theme settings or compiled files, ends up in backups and the repository, after which third-party requests are made on behalf of the site. This is usually noticed by the usage statement, not by logs.

The most costly is a site editor crash. During bulk editing, saving goes into the same synchronous call, the interface becomes unresponsive, and the latest changes are lost.

The editorial team stops trusting the tool and returns to manual proofreading, although formally the plugin "works".

We break down how this is addressed: where the model call is offloaded, how requests become idempotent by post key, and what exactly moves to the server side.

What changes on a WordPress site after implementation

The effect of the AI plugin is visible not in a demo chat, but in the site's own metrics: how long a visitor waits, what share of requests never reaches the model, and what happens during a traffic surge. Below are four outcomes that are measured before and after implementation.

Time to first response fragment

The response is streamed: the widget shows the first words while the model generates the rest, so the wait for the first visible text drops from 4–9 seconds to 0.5–1.5.

The full response arrives in 2–4 seconds — for a visitor, this is the difference between a "live" interface and the feeling of a frozen page.

Share of requests without calling the model

Cache by normalized key (case, extra spaces, stop words) together with semantic matching for similar wording covers 30–60% of repeats — typical questions about delivery, payment, and booking.

The answer is taken from transient storage with a limited lifetime, so neither response time nor model load grows with traffic.

Resilience under load

A request queue with per-visitor rate limiting and retries with increasing delay prevent the site from timing out during a surge.

If the external model service is unavailable, the plugin switches to a predefined scenario: knowledge base hints, a contact form, contacts — instead of an empty block in the interface.

Class of failures that goes away entirely

The most costly breakage disappears — a page crash due to a synchronous model call right in the theme template.

All calls go from the server side through a separate endpoint with timeouts, logging, and a clear error message, so external service unavailability no longer brings down the site or loses requests.

Three approaches to connecting a model: comparison table

The connection scheme is chosen not by "model power," but by three practical questions: where data is stored, what response is considered normal, and what the user will see when the external service is unavailable.

In the plugin, these are three different architectures — an outbound request, model execution in your own environment, and a hybrid with local logic. They differ primarily in limitations.

Limitations are more important than advantages: they determine the scope of work on key protection, caching, request queue, and failure handling.

A hybrid usually offloads typical repeating requests from the external model — only what truly needs text analysis goes out. We fix the scheme choice before development: the plugin structure, key storage method, and widget behavior when the external service fails depend on it.

Work sequence: from site audit to code handover

The work sequence is structured so that risks are uncovered in the first steps, not at acceptance. An error in the integration scheme or access model is the most costly: fixing it means reworking the widget, repeating the load pass, and reconfiguring scenarios. Therefore, audit and design take more time than the code itself.

1. Site and data audit. We examine template structure, connection points in the theme, roles and permissions, active extensions, caching layers. Separately, we look at what data can be sent to the model at all — field composition, personal data, where the boundary of what is acceptable lies.
2. Integration scheme. We fix endpoints, request and response format, authentication method, request limits, and behavior on external service failure. The result is a scheme that lets code be written without guesswork.
3. Task-specific setup. We assemble scenarios: what goes to the model and in what order, how context is formed from page content, how clarifying questions and empty responses are handled.
4. Load testing. We run a surge of concurrent dialogs, measure response time and resource consumption, and check behavior during timeouts, duplicate requests, and connection drops.
5. Acceptance. We compare scenarios with the initial requirements, check logs and request tracing, and separately the rollback scenario: how quickly to return the site to a state without the plugin.
6. Documentation handover. Integration scheme, endpoint map, settings description, key rotation instructions, and rollback checklist — in one package so your engineer can do updates, not only us.
7. First weeks of support. We look at real dialogs and error logs, adjust the model system instruction and trigger thresholds based on actual user behavior.

After that, we hand over the code to your repository and stay in touch for incidents — without dependence on our internal tools.

Deliverables: configurations, diagrams, and policies

The delivery is not an archive with the plugin, but a set of artifacts that your team uses to deploy, configure, and support the solution without us.

Each file has a purpose, owner, and version in the repository, so six months later you don't have to figure out where limits were changed and why. Below is exactly what remains in your hands after handover.

• Configuration files — model connection parameters, timeouts, request limits, and response lengths are moved out of code into separate files with a comment for each option: editing does not require rebuilding the plugin.
• Data flow diagrams — from sending a message in the widget to the model response: where checks are placed, where logs are written, where errors and connection drops are handled.
• Access rules — role matrix: who can change settings and hint texts, who only reads logs, how keys are stored and rotated, what is prohibited from logging.
• Administrator guide — plugin installation and update, initial setup, ways to verify operation, and troubleshooting typical failures: what to check first and what is safe to restart.
• Update and rollback policy — version release procedure, test environment, rule "one version back always available": return to the previous working state without losing settings.
• Check suite — scripts run before deployment that confirm key dialog scenarios and error handling are not broken.
• Dependency map — external services, their roles, and behavior when unavailable, so you understand what exactly degrades and how it affects visitors.

The package is designed for an engineer, not the plugin author: deploy, view logs, change a parameter, and roll back using the docs, without contacting us.

Case study: a chat assistant in a catalog of 40,000 items

A catalog of 40,000 items ran on WordPress, and visitors searched for the right part themselves: going through filters, opening dozens of product cards, comparing specs in a table.

For complex selections — an analog, compatibility, replacement of a discontinued unit — the person left without finding an answer. Meanwhile, the editor manually answered the same questions in email and chat, carving out several hours a week for it.

What we changed

We built a chat assistant on top of the catalog: it reads product cards, specifications, and relationships between items, and in its answer gives not general words but a specific item with a link.

The assistant takes data from the same catalog — when a card is edited, the selection updates automatically, and the editor no longer needs to duplicate descriptions. Heavy selections go into a queue, so a surge of visitors does not bring down the site.

Metrics before and after

"Previously, half of the requests were of the 'find an analog' type. Now the assistant handles such questions, and we focus on complex selections where an engineer is needed," — head of the client's department.

What to do if a ready-made chat widget is already installed on the site?

Yes, an add-on is possible: a ready-made chat widget is most often connected by a script in the site footer and communicates with its own service on the provider side. While it is the only one, no issues arise.

Problems begin when a second solution appears alongside it and both claim the same events on the page.

Module conflict looks predictable: two scripts intercept form submission, duplicate the connection, and fight over the message queue. The operator sees two parallel dialogs, the visitor sees duplicated answers, and the request history spreads across two storages. There is no way to reconstruct the conversation chain from such a trail.

We start the review with an inventory: what events the installed widget listens to, where the request history is stored, and whether there is a server interface for export.

If the interface is open, dialogs are transferred to our database, and the old widget is switched to read-only during the transition.

Then comes a phased replacement. We export the history and operator directory, deploy our solution at a separate address and run it on part of the traffic, compare databases, switch the widget, and only after that disable the previous one.

The site stays operational the entire time, requests are not lost, and rollback at any step remains available.

If there is no server access, part of the history will have to be collected manually, and it is better to understand this before the start, not after. Therefore, we fix the transition plan and rollback points at the task analysis stage, before the first line of code.

Common technical questions before starting work

Before starting, engineering teams ask the same questions — about data security, updates, and the area of responsibility after handover. Below are answers with the specificity usually sufficient to decide on an AI plugin for WordPress.

What happens during a major site update?

The plugin does not modify core or theme files — integration goes through hooks and custom REST routes. The widget survives theme or core updates; when markup changes, the mount point is set in settings, without code edits.

Will the widget withstand a traffic surge?

Requests to the model go asynchronously, repeating questions are served from cache by hash. During a peak, the queue limits parallelism and returns a prepared answer instead of a timeout; the widget script loads after the main content and does not delay rendering.

Can rollout be phased?

Yes: rollout is controlled by flags — by roles, page groups, or share of sessions. We start with a small share of traffic, compare metrics, and expand; rollback is turning off the flag, without code deployment or downtime.

What is included in support after handover?

We hand over the repository, configurations, model exchange scheme, and operating instructions. After that, a defect fix warranty and a separate support policy apply: error monitoring, request limits, scenario and model updates.

Let's discuss the task and come back with an estimate and plan

So that the project estimate is based on facts, not assumptions, a minimal set of initial data for calculation is enough to start.

Describe the widget usage scenario: what the user asks and what answer is considered correct, where the data comes from — catalog, knowledge base, external service — and whether there are restrictions on transferring it.

We'll discuss the task on a call with the engineer who will lead it: we'll clarify the boundaries of the first version and what will deliberately not be included.

After the review, we'll come back with a project estimate and work plan — without general wording and "we'll calculate later."

What you will receive in response:

• project estimate by stage — with effort and timelines, without hidden work;
• work plan with release order: integration, widget front end, checks, launch;
• diagram of plugin interaction with the site and external services, including failure handling;
• list of accesses and roles needed from your side;
• acceptance criteria: which scenarios we check and what we consider a finished result;
• list of risks and assumptions affecting scope and timelines.

Then we'll agree on the project start date and the stage reporting mode. Describe the task in free form or send the current description — we'll come back with an estimate and plan, and discuss debatable points on a call.