Ring moved support for 10 regions to Amazon Bedrock Knowledge Bases and cut costs

Ring shared how it restructured its global customer support from a rule-based chatbot to a RAG system on top of Amazon Bedrock Knowledge Bases. Instead of separate infrastructure for each market, the company maintained one centralized architecture, preserved regional accuracy of responses, and reduced scaling costs by 21% for each new market.

Why the old bot wasn't working

Initially, Ring's support service relied on an Amazon Lex chatbot with hard-coded scenarios. This approach worked as long as requests remained predictable, but quickly hit a ceiling: during peak loads, 16% of conversations had to be escalated to live operators, and engineers spent about 10% of their time supporting and fixing the bot itself. For an international service, this became too expensive and slow a model.

The problem wasn't just interface translation. Different markets require different answers accounting for local parameters: from device specifications and voltage to certification requirements and regulatory compliance. Ring was already operating in the UK, Germany, and eight other regions, and maintaining separate infrastructure for each market meant growing costs and operational complexity almost linearly.

How they built the new architecture

In the new architecture, Ring separated content work into two loops: ingestion and evaluation separately, promotion to production separately. The content team uploads instructions, guides, and support articles to Amazon S3 in structured format, where each document has metadata including `contentLocale`. Then AWS Lambda automatically distributes raw content and extracted metadata to the appropriate buckets, and Step Functions builds a new version of the knowledge base each day.

• Content is uploaded to S3 with locale and document type metadata
• Lambda archives the raw file and saves cleaned data for indexing
• Step Functions creates a new Knowledge Base version daily
• Evaluation datasets run queries against versions and compare output quality
• The best version goes into the Golden Data Source for production

This pipeline allowed Ring to update knowledge without manual deployment and without risking production issues. Each daily version lives as a separate knowledge base, so it can be tested and rolled back independently. History is retained for up to 30 days — this is sufficient because content changes about 200 times per week.

For automatic quality checks, Ring uses Anthropic Claude Sonnet 4 as a judge: it compares versions on search accuracy, response quality, and metrics for each locale.

How the bot chooses an answer

On the user side, the architecture is equally pragmatic. The client sends a question to the chatbot along with the market, for example `en-GB`. Lambda doesn't search the entire database blindly but applies a metadata-driven filter on the `contentLocale` field so the query goes directly to the relevant regional corpus only. After that, the system retrieves the found fragments from the verified Golden version, sorts them by score, assembles an expanded prompt, and sends it to the Amazon Bedrock model for the final answer.

Ring separately notes that the requirement for complete response latency was 7–8 seconds, and analysis showed an important finding: inter-regional latency accounted for less than 10% of total response time. This made it possible not to duplicate the entire architecture in each region but to keep a single request processing center.

For vector storage, the company uses Amazon OpenSearch Serverless, and for embeddings — Amazon Titan Embeddings with standard chunking. The system is planned to evolve toward an agentic approach, where separate specialized agents will be responsible for device diagnostics, order management, and product recommendations.

What this means

Ring's case is useful not as an AWS showcase but as a working template for any company with international support. The main idea is simple: don't create separate RAG systems per country but maintain one database with strict metadata filtering, daily evaluation of new versions, and a clear mechanism for promotion to production. This reduces scaling costs, simplifies maintenance, and makes answers more predictable in each market.