It can summarize customer histories, generate campaigns, prepare sellers for meetings, resolve service requests, and execute increasingly complex sequences of tasks. The more interesting question emerging from Dreamforce is what happens when those capabilities stop living inside isolated pilots and begin operating across the enterprise.

Rather than center Dreamforce on a single breakthrough model or another generation of copilots, Salesforce outlined pieces of a much broader agentic architecture: AIforce as a new interface layer, specialized reasoning through Koa, increasingly autonomous agents, and an enterprise framework intended to govern agents and models across ecosystems.

Taken together, these announcements point to a larger shift:

Enterprise AI is moving from a feature inside software to a layer connecting people, data, decisions, and actions across the business.

The challenge isn’t simply adopting more AI. It’s deciding how applications, interfaces, data, governance, and human judgment should work when AI becomes an active participant in the enterprise.

The Future of Enterprise Software May Be Less About the Interface

One of the biggest ideas shared at Dreamforce was also one of the simplest: What if users don’t have to open an application to benefit from everything behind it?

AIforce is Salesforce’s answer. Positioned above Data 360, Customer 360, and Agentforce, AIforce is intended to make Salesforce data, workflows, and permissions available through the environments where people already operate. Its initial surfaces illustrate the strategy: Claudeforce brings Salesforce into Claude, Slackforce brings Salesforce context to Slack, and Agentforce Coworker provides an AI teammate within Salesforce itself.

Enterprise applications have traditionally asked users to come to them. Users learn the interface, find the right record, navigate the right workflow, and move information from one application to another.

Agentic interfaces potentially reverse that relationship. The system comes to the user, bringing the appropriate data, permissions, and actions with it.

One Model Isn’t Going to Run the Enterprise

Another highlight is an enterprise AI environment where different models perform different jobs.

Koa, Salesforce’s new CRM-specific reasoning model, is one example. Rather than positioning it as a replacement for general purpose models, Salesforce designed Koa for specialized CRM reasoning while models like Claude or ChatGPT can continue handling more general tasks.

This reflects a maturation in enterprise AI strategy.

Early generative AI encouraged organizations to think in terms of model selection: Which model is best? Which provider should become our standard? Which one wins?

The more likely enterprise architecture is heterogeneous. A general-purpose model may be appropriate for one interaction; a domain-specific reasoning model may outperform it for another. Some processes may require deterministic logic alongside probabilistic reasoning. Different cloud environments or data constraints may introduce still more options.

Salesforce’s growing partnerships with Anthropic, AWS, Google Cloud, NVIDIA, and others reinforce that direction.

The strategic advantage may not come from picking a single model. It may come from building an architecture capable of choosing the right intelligence for the right task without forcing the enterprise to rebuild everything around it.

Agents Are Becoming More Specialized and More Autonomous

Dreamforce also revealed another notable change in how Salesforce talks about agents. They increasingly look less like generic AI features and more like specialized digital roles.

Salesforce introduced agents spanning customer service, IT and HR, commerce, supply chain, lead qualification, and outbound sales.

For example, Hunter, Salesforce’s outbound sales agent, is built on what Salesforce describes as a long-horizon runtime. Rather than handling a single interaction and stopping, it’s designed to maintain a goal across days or weeks, use memory, and adjust as circumstances change.

As agents become capable of operating across longer time horizons, leaders will need to define not only what agents can do, but what they should own. Which decisions can they make independently? Which actions require approval? What conditions should trigger human intervention? Who is accountable when an autonomous sequence produces an unexpected result?

The AI Stack is Getting More Complex Just as the Interface Gets Simpler

For the user, AI may make enterprise technology simpler. Ask a question in Claude, Slack, or an AI coworker and let the underlying systems determine what data, model, or agent should respond.

Behind that simplicity, however, the technology environment becomes considerably more complicated.

Organizations may have agents from Salesforce alongside agents from other platforms. Multiple models may reason over the same business context. An agent could call another agent or cross several enterprise systems before completing an action. This makes governance less of a policy exercise and more of an architectural requirement.

Salesforce’s Trusted Enterprise AI Harness reflects this. Its framework brings together context, agency, action, governance, security, and models, supported by an AI Control Plane intended to help organizations discover, register, and monitor agents, including third-party agents.

Organizations have historically governed access primarily around people and applications. An agentic enterprise introduces another participant: nonhuman actors capable of accessing information, making decisions, and taking action.

This requires organizations to rethink identity, permissions, observability, and accountability at the same time they’re expanding AI access. The companies that solve this well won’t simply have stronger guardrails – they’ll have greater freedom to experiment because they’ll understand where their agents are, what they can access, and what they’re doing.

AI Readiness is Really Enterprise Readiness

All of this makes the path from pilot to production more demanding than another round of technology deployment. AIforce can expose business functionality through new interfaces. Specialized models can improve reasoning in targeted contexts. Long-horizon agents can pursue objectives over time. An enterprise AI architecture can govern interactions among them.

An AI-powered interface can’t compensate for customer data employees themselves don’t trust. An autonomous agent can’t reliably execute a process that the organization can’t clearly define. Model orchestration does little good if systems can’t exchange context or actions consistently. And agent governance becomes difficult when permissions were never designed with nonhuman actors in mind.

That’s why adding another AI pilot can create the illusion of progress.

A controlled pilot asks whether a technology can succeed under favorable conditions. Scale exposes everything around the technology that isn’t ready.

Organizations preparing for this next phase should be asking:

• Is the data sufficiently trusted and contextualized for an agent to act on it?
• Can agents carry identity and permissions appropriately across systems?
• Which decisions require human judgment, and which can safely be delegated?
• Can actions move reliably across the applications required to complete an outcome?
• Can the enterprise monitor agents across platforms rather than one ecosystem at a time?
• What happens when an agent fails, encounters ambiguity, or behaves unexpectedly?
• How will users’ responsibilities change as agents take on more persistent roles?

The Real Opportunity Isn’t More AI. It’s a Different Enterprise.

Dreamforce provided plenty of individual technologies to evaluate. AIforce challenges where employees interact with enterprise systems. Claudeforce and Slackforce demonstrate how business context can escape the traditional application interface. Koa points toward a multi-model future. Longer-running agents expand the boundaries of autonomous action. And Salesforce’s emerging governance architecture acknowledges the complexity all of this creates.

Enterprise software itself is being reassembled. The interface is becoming more fluid. Intelligence is becoming more specialized. Agents are becoming more persistent. Platforms are becoming more interoperable. Governance is moving deeper into the architecture.

This should change how leaders approach AI investment.

The next step isn’t to accumulate as many agents, models, or pilots as possible. It’s to decide what kind of enterprise those technologies are entering.

Where should intelligence live? Which systems should remain sources of truth even when users no longer interact with them directly? Which decisions should AI influence versus own? What capabilities need to be shared across every model and agent? And where will human judgment become more important because automation has taken over everything around it?

The first phase of enterprise AI proved that the technology can do remarkable things. The next phase is about building an enterprise that can trust it to do them at scale.

The post Dreamforce 2026: AI Has Left the Pilot. Now Comes the Hard Part. appeared first on Perficient Blogs.

Claims processing, prior authorization, utilization management, risk adjustment, and member benefits operate under precise policies, effective dates, audit requirements, and legal accountability. Yet the AI technologies being introduced into these workflows, including large language models, generative AI, and machine learning, are probabilistic by design. 

The same clinical document processed twice may produce slightly different summaries. A fraud model retrained on newer claims data may assign a different score to an unchanged claim. A benefits assistant may interpret “Is PT covered?” differently from “Does the member have physical therapy benefits?” 

This variability is not simply a defect that better prompting will eliminate. It is a characteristic of this technology. 

The real challenge is not to make every AI component deterministic. It is to build a controlled, reproducible, and auditable system around non-deterministic components. 

Why Healthcare Payers Are Different 

In consumer applications, small variations in recommendations or generated language may be acceptable. In payer operations, the same variation can influence coverage, payment, provider review, coding, or a member’s financial decisions. 

In prior authorization, AI can extract clinical facts and summarize lengthy medical records. However, an omitted diagnosis, unsupported statement, or incorrect policy association can affect a consequential determination. 

In claims adjudication, identical claims evaluated with the same data, policy, rules, and effective date should produce the same result. AI may assist with classification, extraction, and exception routing, but deterministic services should continue to calculate the final outcome. 

In fraud, waste, and abuse, a high anomaly score is not a defensible explanation by itself. The model version, contributing features, threshold, supporting evidence, rules, and investigator actions must be traceable. 

The same principle applies to coordination of benefits. If AI identifies another insurer or suggests a coverage order, the system should show the member and policy information supporting that recommendation, the checks performed, and the final reviewer decision. 

These are not merely model-accuracy problems. They are system-accountability problems. 

More Instructions Do Not Guarantee More Control 

A common response to inconsistent AI behavior is to expand the prompt: 

• Follow every policy. 

• Check all eligibility conditions. 

• Never hallucinate. 

• Apply every exception. 

• Cite the source. 

• Return the required structure. 

• Escalate uncertain cases. 

More instructions may improve performance initially, but long prompts eventually introduce instruction saturation. Policies, examples, retrieved documents, conversation history, formatting constraints, and business rules compete for the model’s attention. 

This creates exposure to the “lost-in-the-middle” effect, where relevant information may be present in a long context but not used consistently, particularly when critical evidence or instructions are buried between other content. 

The architectural implication is straightforward:  

If a requirement must always be followed, it should not exist only as a prompt instruction. 

Critical requirements should be implemented as executable rules, schemas, effective-dated queries, validations, authorization controls, and workflow gates. 

Separate Language from Decisions 

A Benefit Assist use case for example illustrates the right architectural pattern. 

When a member asks whether physical therapy is covered, the answer may depend on the member’s plan, plan year, date of service, eligibility, network tier, benefit limits, accumulators, authorization requirements, riders, exclusions, and coordination of benefits. 

A language model should not infer these facts or calculate the benefit. 

The LLM should identify the intent, normalize the question, and explain the validated response. Deterministic services should retrieve the applicable data, and a rules engine should calculate the benefit. 

A controlled Benefit Assist flow should: 

1. Identify the member’s intent. 
2. Map the request to a defined benefit category. 
3. Retrieve eligibility, plan, network, accumulator, and policy data. 
4. Apply effective-dated business rules. 
5. Assemble the result using an approved response structure. 
6. Allow the LLM to simplify the language without changing the determination. 
7. Cite the source, effective date, and data timestamp. 
8. Escalate ambiguous, unsupported, or high-risk questions. 

This separation preserves conversational usability without allowing the model to become the source of truth. 

Engineering Deterministic Boundaries 

High-impact AI workflows should version the model, prompt, tools, retrieval configuration, embedding model, policy corpus, rules package, output schema, and post-processing logic. Model and prompt changes should be treated as controlled releases with regression testing and approval gates. 

Generated outputs should follow defined schemas. Required evidence, citations, rule identifiers, confidence measures, missing information, and escalation reasons should be explicit. Invalid or unsupported outputs should fail validation rather than flow silently downstream. 

Human oversight must also be designed into the architecture. AI may extract, classify, summarize, and recommend. Authorized people should approve consequential outcomes, particularly when policy ambiguity, incomplete evidence, clinical complexity, or member impact is high. 

Confidence alone should never determine automation. A confident response can still be ungrounded, based on an expired policy, or inconsistent with structured member data. 

Evaluate the System, Not Just the Model 

Traditional accuracy metrics are insufficient for agentic payer workflows. Evaluation should include: 

• Idempotency: Does the same request, data, model, tools, and rules produce the same business outcome? 

• Rules compliance: Were the correct rules, exceptions, effective dates, and precedence conditions applied? 

• Groundedness: Is every consequential claim supported by an authorized source? 

• Retrieval quality: Did the system retrieve the correct document version and relevant passage? 

• Consistency: Do equivalent questions produce the same intent, retrieval, rule execution, and material answer? 

• Regression: Do model, prompt, retrieval, or policy changes alter critical outcomes? 

Groundedness alone is not enough. An answer can be grounded in the wrong plan document and still be operationally incorrect. Reliability must therefore be measured across the complete execution path. 

That path must also be reconstructable. A regulator-ready audit trail should capture the request, idempotency key, source-data versions, model and prompt versions, tool calls, retrieved evidence, rules evaluated, raw output, validation results, human actions, and final outcome. 

The Mental Model That Changes Everything 

The AI model is not the system. 

It is one probabilistic component within a larger platform of authoritative data, deterministic retrieval, executable rules, validation gates, human accountability, monitoring, and audit controls. 

The objective is not identical wording across every model response. The objective is a workflow that produces consistent, evidence-based, policy-compliant, explainable, and reproducible business outcomes. 

The healthcare payers that succeed with AI will not necessarily be those that deploy it fastest. They will be those that build the governance and engineering infrastructure required to operate it safely at scale. 

Control is not the opposite of innovation. Control is what makes sustainable innovation possible. 

The post Determinism on a Non-Deterministic Platform: The AI Challenge for Healthcare Payers appeared first on Perficient Blogs.

Three tools that cover the full build path — Google Stitch for design, Google AI Studio for prototyping with AI, and Claude Code for shipping the actual code.

How to Read This

The three tools below sit at three different points of the same journey. Stitch turns an idea into screens you can look at. AI Studio turns an idea into a working AI prototype you can click. Claude Code turns a decision into code that’s committed to your repository. Used together they compress the distance from “what if we built…” to something real.

Each section shows what the tool looks like in use, lists what it does, and walks through two concrete scenarios. The screenshots are illustrative mockups of the workflow, not captures of anyone’s account — the intent is that someone who has never opened these tools can look at a page and understand what happens.

1. Google Stitch — Describe a Screen, Get the Design

Stitch is Google’s AI-powered UI design tool, built by Google Labs and powered by Gemini. You describe the interface you want in plain language — or upload a hand-drawn sketch or a screenshot — and it generates high-fidelity screens for web or mobile. From there you keep refining conversationally: ask for a darker theme, a different layout, an extra screen, and it updates the design.

The reason it matters isn’t just speed of mockups. Stitch closes the gap between design and development: the same screens can be exported to Figma for a designer to refine or exported directly as front-end code (HTML/CSS, Tailwind, React) for a developer to build on. That removes the usual handoff step where a design has to be rebuilt from scratch in code.

What It Looks Like in Practice

Key Features

• Text-to-design: describe the screen in normal language and get a complete, laid-out interface with colours, spacing, and components.
• Image-to-UI: upload a napkin sketch, a wireframe, or a competitor’s screenshot and get a clean, editable design in that direction.
• Theme controls: switch light and dark mode, set primary colours, corner radii, and fonts from a sidebar — changes cascade across every screen at once.
• Annotate: mark up a generated screen with comments and visual notes; the AI reads the annotations and applies the changes.
• Interactive prototyping: link screens into a clickable flow so a journey can be walked through rather than just described.
• Export both ways: push designs to Figma for design refinement, or take the generated front-end code straight into development.

Use Case in Practice

A practical note: Stitch is still a Labs-stage product, so results vary — it’s excellent for exploration, early concepts, and getting alignment quickly, but treat its output as a strong first draft rather than a finished design system. Teams that need generated UI constrained to their own production component library will still want a designer in the loop.

2. Google AI Studio — The Fastest Way to Prototype With AI

Google AI Studio is a free, browser-based workspace for building with Gemini, Google’s AI model family. At its simplest it’s a prompt playground: write a prompt, pick a model, adjust settings like temperature and max tokens, and see the result instantly — no setup, no billing, no installation. Sign in with a Google account and start.

What makes it more than a playground is what comes after the prompt works. “Get code” exports the exact API call as Python, JavaScript, or cURL so a developer can drop it into a real application. It issues free API keys. It handles text, images, audio, and video in the same interface. And its Build mode can generate and deploy whole working apps from a natural-language description, including full-stack web apps and native Android apps, with Google Workspace integrations wired up automatically.

Key Features

• Prompt playground: test and compare prompts across Gemini models, and tune parameters like temperature and top-P to control how creative or deterministic the output is.
• Multimodal input: work with text, images, audio, and video in one place rather than needing separate tools.
• Get code: export any working prompt as a ready-to-paste API call in Python, JavaScript, or cURL.
• Free API keys: generate a key from a single Google account — no cloud project or billing setup required to start.
• Build mode: describe an app in plain language and have it generated, previewed, and deployed; supports full-stack web apps and native Android apps.
• Large context window: Gemini models in AI Studio handle very long inputs, so entire documents or transcripts can go in at once.

Use Case in Practice

3. Claude Code — An AI Agent That Works in Your Codebase

Claude Code is Anthropic’s agentic coding tool. Rather than being a chat window you copy code out of, it runs where the work already happens — in the terminal, in your IDE, in the desktop app, or in the browser — with direct access to your project. You describe what you want in plain English and it plans, reads the relevant files, makes the edits, runs the tests, and tells you what it did.

It works in a loop: gather context, take action, verify results, and repeat until the task is done. You can interrupt and redirect at any point. Because it can run commands and edit files directly, it handles the full task rather than the snippet — finding the bug, fixing it, running the test suite, and offering to commit. It also connects through MCP to outside sources like Google Drive, Figma, Slack, or Jira, so it can read a design doc or update a ticket as part of the same job.

Key Features

• Build features from descriptions: explain what you want in plain English; it makes a plan, writes the code, and checks that it works.
• Debug and fix: paste an error message or describe the bug, and it traces the cause through the codebase and implements a fix.
• Understands the whole project: it keeps awareness of your project structure, so you can ask questions about an unfamiliar codebase and get real answers.
• Takes action directly: edits files, runs commands, runs tests, and creates commits, rather than handing back text for you to paste.
• Works everywhere: terminal, VS Code, JetBrains, desktop app, browser, Slack, and CI pipelines — the same agent across surfaces.
• Scriptable and automatable: it can be piped into and run non-interactively, so routine jobs can run automatically in CI.
• Extensible via MCP: connect it to Google Drive, Figma, Slack, Jira, or internal tooling so it can pull real context into a task.

Use Case in Practice

Where Each Tool Fits

A quick reference for deciding which tool a given task belongs to.

Closing Thought

What these three have in common is that they lower the cost of trying something. A design concept, an AI feature, a fix to a messy piece of code — each used to be expensive enough that it needed justifying in advance.

The post AI Tools Briefing: From Idea to Interface to Working Code appeared first on Perficient Blogs.

We’re proud to share that several Perficient experts were interviewed as part of the research process for Forrester’s The State of Agentic Commerce, Q2 2026 (Forrester Research, Inc., May 2026). To Perficient, their participation reflects more than where the market is heading. It reflects where Perficient is already delivering today, bringing AI, data, commerce platforms, customer experience, and operations together to create measurable outcomes.

What the Report Reveals

Forrester’s report examines how agentic commerce could reshape product discovery and purchasing across consumer and business markets — and the gap between the current hype and where the technology actually stands today.

That gap should not be mistaken for a reason to wait.

According to Forrester,

Currently, approximately one in 10 users who regularly use answer engines are authorizing answer engines to act semi-autonomously (i.e., without direct supervision) to complete tasks for them. Another 23% say they haven’t done so yet but would in the future.

Fully autonomous commerce may still be taking shape, but AI-powered interfaces are already changing how buyers find and evaluate products. Answer engines and AI assistants can assemble recommendations before a buyer reaches a website, contacts a sales representative, or requests a quote.

The buying journey is not disappearing.  Buyers are entering it through new channels.

For commerce leaders, that raises a more immediate question: Can AI systems find, understand, and accurately represent their products?

Product Data Determines Whether Agents Find You

Traditional commerce strategies have focused heavily on websites, search, marketplaces, and sales channels. Those experiences remain important. But an AI agent does not evaluate a product the way a person does.

The agent relies on available data to understand technical attributes, applications, pricing, availability, delivery options, and compatibility. When that information is incomplete or inconsistent, the product can leave the consideration set before the company receives any signal of buyer interest.

A person may contact sales for clarification. An AI agent can simply recommend a competitor.

This is especially critical in B2B commerce, where companies manage thousands of complex SKUs, account-specific catalogs, negotiated prices, and configuration-dependent products. Product information management cannot remain a one-time cleanup project. It must become an operating discipline supported by governance, structured attributes, consistent syndication, and clear ownership.

Agentic Commerce Readiness Goes Beyond Discovery

Product data is the foundation, but readiness does not end there.

Agent-driven transactions will place new demands on commerce platforms, order management systems, inventory services, and fulfillment operations. If an agent cannot confirm stock, validate account pricing, reserve inventory, or provide an accurate delivery date, it will route the transaction elsewhere.

That loss may happen quietly. No abandoned-cart alert. No support ticket. No opportunity for a sales team to intervene.

Measurement must evolve as well. A buyer may discover a product in an answer engine and complete the purchase through a distributor, marketplace, procurement platform, or sales representative. Traditional analytics may capture the transaction without recognizing where the decision began.

Commerce teams need to treat AI-mediated discovery as an influence channel. That means tracking answer-engine referrals, assisted conversions, agent interactions, and the product attributes that improve visibility.

How Perficient Helps Commerce Organizations Prepare

Our team connects commerce strategy, data, AI, customer experience, and delivery. We help organizations tie pilots to the data, platforms, and operating processes needed to measure results.

That work includes strengthening product data foundations, modernizing commerce and order management architectures, improving product findability, deploying practical AI use cases, and building measurement models for emerging customer journeys.

Our AI-first approach applies AI where it removes friction, improves decisions, and produces measurable results. That is what it means to be Different for real: AI-first solutions backed by disciplined delivery and measurable outcomes.

Preparing for What Comes Next

Commerce leaders do not need to predict exactly when agentic commerce will reach full autonomy. They need to prepare for a buying environment in which agents play a larger role in discovery, evaluation, and transactions.

Strengthen product data first. Then test real-time fulfillment capabilities and measure AI-driven discovery. Build a readiness roadmap using short execution cycles.

Agentic commerce is still maturing. The companies building the right foundations now will be ready when buyer behavior catches up.

Forrester clients can access The State of Agentic Commerce, Q2 2026 directly through Forrester.

The post Agentic Commerce Readiness Starts with Product Data appeared first on Perficient Blogs.

1. Smart Reconciliations

One of the most powerful applications of AI in the financial close process is automating reconciliations. Traditional methods require manual comparisons of transactions across systems—tedious and time-intensive work. AI algorithms can analyze vast amounts of transactional data, identify anomalies, and automatically match records with high accuracy. This not only accelerates the process but also flags exceptions for human review, ensuring both speed and accuracy.

2. Predictive Close and Error Detection

AI can learn from historical close data to predict how long each step in the process will take and where issues are likely to arise. This proactive insight helps accounting and finance leaders allocate resources more effectively and avoid surprises. Machine learning models can also detect irregular patterns or inconsistencies that might indicate errors or fraud, giving teams more confidence in the numbers.

3. Natural Language Processing (NLP) for Reporting

AI-driven NLP tools can generate narrative summaries of financial performance, explaining variances and trends in plain language. This reduces the time spent preparing management reports and makes financial insights more accessible to non-financial stakeholders.

4. Workflow Automation

AI can optimize the close checklist by tracking task dependencies, monitoring progress, and sending automated alerts to keep the process on schedule. It acts like a digital project manager—ensuring nothing falls through the cracks.

5. Continuous Close Capabilities

With AI, the concept of a continuous close becomes more feasible. Instead of waiting until month-end to reconcile and report, AI tools can process and analyze data in real time throughout the month. This creates a faster, more agile accounting and finance function with more timely insights. 

Final Thoughts 

AI doesn’t replace accounting or finance professionals—it empowers them. While this may sound cliché, AI provides a starting point and developed approach that can be reviewed and completed by the human team.  By automating routine tasks and providing smarter insights, AI allows accounting and finance teams to focus on strategic activities, reduce errors, and close the books faster. For organizations looking to modernize their finance operations, investing in AI-driven close solutions is no longer a futuristic idea—it’s becoming a competitive necessity. 

The post How AI is Transforming the Monthly Financial Close Process appeared first on Perficient Blogs.

Brickbuilder Specialization: Lakeflow

Brickbuilder Specialization: Security & Governance 

Data governance isn’t a compliance checkbox. It’s the foundation that determines whether your organization can scale AI, maintain trust, and operate across regulatory boundaries without breaking. Most enterprises run scattered governance models that fragment security, slow analytics, and block AI adoption before it starts. 

Perficient’s Databricks Brickbuilder Specialization for Security & Governance recognizes our deep expertise in helping organizations confidently secure, govern, and scale their data and AI on the Databricks Data Intelligence Platform. With Unity Catalog at the center, we build governance frameworks that enable security without sacrificing speed. 

We empower enterprises to: 

• Establish unified, enterprise-grade governance frameworks across data, analytics, and AI workloads 
• Strengthen security with fine-grained access controls and automated data lineage tracking 
• Improve data quality, trust, and discoverability with consistent governance patterns across domains 
• Enable secure, seamless data sharing across clouds and partners with Delta Sharing 
• Empower business teams with AI-driven insights through AI/BI Genie, governed analytics experiences, and Perficient’s AI/BI Genie workshop designed to help organizations identify high-value use cases and accelerate adoption
• Monitor and optimize platform health, performance, and cost with native Lakehouse Observability 

We deliver governance that scales with your business — not against it. 

Brickbuilder Specialization: Data Warehouse Migration

Legacy data warehouses trap data in silos, slow modernization efforts, and break when you try to scale. Most migration approaches either lift-and-shift technical debt into the cloud or drag timelines into multi-year efforts that never fully deliver. Neither model works. 

Perficient’s Databricks Brickbuilder Specialization for Data Warehouse Migrations recognizes our proven expertise in modernizing legacy data warehouses and migrating organizations to the Databricks Data Intelligence Platform. Through our Agentic Migration Factory, agent-assisted migration methodology, and specialized automation frameworks, we transform migration from a risk-heavy project into a repeatable, accelerated path to modern lakehouse architectures. Our approach combines AI-powered assessment, code conversion, validation, and optimization to reduce effort while improving migration quality and speed.

We empower enterprises to: 

• Migrate from legacy systems and cloud warehouses to modern lakehouse architectures that unify analytics and AI 
• Accelerate migration timelines and reduce costs using pre-built code and automated tools 
• Leverage Unity Catalog and Databricks SQL for unified analytics, AI workloads, and improved performance 
• Move beyond “lift and shift” to true data modernization with enhanced reliability and cost-efficiency 
• De-risk complex migrations with repeatable frameworks that reduce manual effort and technical complexity 
• Leverage Perficient’s Agentic Migration Factory, proprietary IP, and automation accelerators to streamline assessment, conversion, validation, and modernization

We deliver migrations that modernize your data infrastructure — transforming legacy constraints into competitive advantages with speed, precision, and proven methodology. 

Brickbuilder Specialization: AI

Most AI initiatives stall in pilot mode. The challenge isn’t model sophistication — it’s building AI systems that perform reliably in production, govern effectively, and scale across the enterprise. Fragmented tools, incomplete data foundations, and unclear operationalization paths keep AI stuck in experimentation. 

Perficient’s Databricks Brickbuilder Specialization for AI recognizes our deep expertise in deploying Generative AI, machine learning, and agentic solutions on the Databricks Data Intelligence Platform. Using Databricks, we move from AI experimentation to operationalized AI outcomes with proven accelerators designed for enterprise complexity, including Perficient’s AI Studio and AI AMP frameworks that help organizations rapidly design, deploy, govern, and scale AI solutions.

With Brickbuilder Accelerators and specialized frameworks, we empower enterprises to: 

• Build production-grade AI agents with a focus on creation, evaluation, governance, and deployment 
• Accelerate time to value with pre-built code and industry-specific AI solutions 
• Enrich models tailored to unique datasets for summarization, classification, and beyond 
• Deploy AI-driven analytics for healthcare, life sciences, financial services, and retail sectors 
• Accelerate AI development and governance with Perficient AI Studio and reusable enterprise AI frameworks
• Move from AI strategy to implementation with AI AMP workshops designed to identify, prioritize, and operationalize high-value AI opportunities
• Scale Generative AI and machine learning initiatives with confidence on trusted data foundations 

We deliver AI that moves beyond experimentation — transforming AI potential into measurable business impact with speed, precision, and industry expertise. 

What Brickbuilder Specializations Mean 

Databricks Brickbuilder Specializations validate more than technical capability. They confirm proven delivery, measurable outcomes, and deep expertise in the domains that determine whether data and AI initiatives succeed at scale. 

Our specializations reflect what we deliver every day: security and governance frameworks that enable scale without breaking compliance, migration expertise that modernizes legacy systems without multi-year timelines, and AI capabilities that move from pilots to production. These specializations are further strengthened by Perficient’s proprietary accelerators, including Assetflow, AI/BI Genie Workshops, Agentic Migration Factory, AI Studio, and AI AMP, which help clients reduce risk, accelerate delivery, and achieve measurable business outcomes faster.

These aren’t credentials we pursued for marketing. They’re recognition of the work we’ve already delivered — and validation of the outcomes our clients rely on. 

Building on a Foundation of Proven Expertise 

As a Databricks Gold Partner with over 200 certified professionals, 6 Databricks Champions, and now 4 Databricks specializations, Perficient delivers unified data, analytics, and AI systems that perform under operational pressure. 

We don’t chase certifications. We pursue outcomes — solutions that hold up in production, scale with your business, and deliver measurable results on the Databricks Data Intelligence Platform. 

Ready to transform your data and AI from potential to production? 

Learn more about our Databricks capabilities 

The post Perficient Achieves Databricks Brickbuilder Recognition Across the Full Platform appeared first on Perficient Blogs.

Why Testing a RAG System is Different

Testing a traditional API is straightforward: given input X, expect output Y. Testing a RAG system is categorically different. You are simultaneously validating:

• Data quality — are the right documents ingested correctly?
• Chunking quality — are chunks meaningful and complete?
• Embedding quality — do similar topics score highly together?
• Retrieval accuracy — are the most relevant chunks returned?
• LLM output quality — is the answer grounded, accurate, and complete?
• Security — is the system resistant to prompt injection and PII leakage?

Each layer can fail independently. A perfect LLM with bad retrieval still produces bad answers. This is why RAG testing requires a layered, systematic approach.

The most expensive RAG failure is silent degradation — retrieval quality slowly drifts as documents change, and nobody notices until users stop trusting the system.

The RAG Testing Pyramid — 4 Layers

Borrow the concept of the traditional test pyramid and apply it to RAG. Build from the foundation up:

Layer 1: Data Quality Testing

This is the cheapest, fastest layer — and the most overlooked. Bad data causes silent failures downstream.

• Are all expected source documents present in the vector DB?
• Are there any duplicate chunks (same content stored twice)?
• Are any chunks empty, too short (< 50 tokens), or garbled text?
• Is metadata complete — source filename, page number, and ingestion date?

def test_no_empty_chunks(chunks):
    for chunk in chunks:
        assert len(chunk.text.strip()) > 50, f'Empty chunk: {chunk.id}'
        assert chunk.metadata['source'] is not None

def test_no_duplicate_chunks(chunks):
    texts = [c.text for c in chunks]
    assert len(texts) == len(set(texts)), 'Duplicate chunks detected'

def test_document_count(vector_db, expected_count):
    actual = vector_db.get_document_count()
    assert actual >= expected_count, f'Expected {expected_count}, got {actual}'

Layer 2: Embedding Quality Testing

• Embedding generated for every chunk — no nulls or errors
• Correct vector dimensions: 1536 (Azure), 1024 (AWS/OCI)
• Semantically similar chunks score above 0.80 cosine similarity
• Unrelated chunks score below 0.30 — no false positives

def test_embedding_dimensions(embedding):

    assert len(embedding) == 1536  # For Azure text-embedding-3-small

def test_semantic_similarity():

    score = cosine_similarity(

        embed('annual leave entitlement'),

        embed('how many days holiday do I get?')

    )

    assert score > 0.80, f'Similarity too low: {score}'

def test_dissimilar_chunks_score_low():

    score = cosine_similarity(

        embed('leave policy'), embed('network firewall rules')

    )

    assert score < 0.30, f'False similarity detected: {score}'

Layer 3: Retrieval Testing with RAGAS

RAGAS (Retrieval Augmented Generation Assessment) is the industry-standard framework for evaluating RAG systems. It provides metric-driven, reproducible evaluation across your entire pipeline.

Context Precision — ‘Is what we retrieved actually relevant?’

Measures the proportion of retrieved chunks that are genuinely relevant to the question.

# Example calculation:
# Retrieved 5 chunks for: 'What is the expense claim limit?'
# Relevant: chunks 1, 3, 4  (about expenses)
# Irrelevant: chunks 2, 5  (about leave policy, office hours)
# Context Precision = 3/5 = 0.60  -->  FAIL (threshold: 0.80)

Context Recall — ‘Did we retrieve everything needed?’

Measures whether all facts required to answer correctly were present in the retrieved context.

# Example calculation:
# Ground truth answer requires 4 key facts
# Retrieved context contains 3 of those facts
# Context Recall = 3/4 = 0.75  -->  PASS (threshold: 0.75)

from ragas import evaluate

from ragas.metrics import context_precision, context_recall

results = evaluate(
    dataset=test_dataset,  # questions + ground truths + retrieved contexts
    metrics=[context_precision, context_recall]
)

assert results['context_precision'] >= 0.80, 'Precision below threshold'
assert results['context_recall']    >= 0.75, 'Recall below threshold'
print(f"Precision: {results['context_precision']:.2f}")
print(f"Recall:    {results['context_recall']:.2f}")

Layer 4: LLM Response Testing — Hallucination Detection

The Four Response Quality Metrics

Hallucination in Detail

Faithfulness measures whether every claim in the LLM’s answer can be traced back to the retrieved context. A claim that cannot be traced is a hallucination.

# Context says: 'Employees are entitled to 20 days annual leave per year'
#
# BAD answer: 'Employees get 25 days plus 5 bonus days for performance'
# --> '25 days' and 'bonus days' are NOT in context
# --> Faithfulness = 0.0  -->  HALLUCINATION  -->  FAIL
#
# GOOD answer: 'According to company policy, employees receive 20 days annual leave'
# --> Every claim traces back to the context
# --> Faithfulness = 1.0  -->  PASS

Additional hallucination detection tools:

• DeepEval HallucinationMetric — standalone hallucination scorer with explanation
• PromptFoo — test known Q&A pairs, flag when answers deviate from expected output
• LangSmith — full chain tracing to see exactly what context was passed and what was generated

The Complete Enterprise CI/CD Pipeline

Every RAG system change — whether code, documents, or configuration — must go through this automated quality gate before reaching production.

The most important insight: RAGAS evaluation is NOT just a one-time quality check. Run it continuously in production. Retrieval quality drifts as your document base evolves.

QA Automation Framework — The Complete Stack

As a QA Lead or SDET on a RAG project, this is your complete toolbox:

Check Type	Tool	What is Validated
API Testing	PyTest + Requests	REST endpoints, response codes, latency SLA
Vector DB Validation	PyTest	Chunk count, metadata integrity, index health
Retrieval Accuracy	RAGAS	Context Precision ≥ 0.80, Context Recall ≥ 0.75
Hallucination Detection	DeepEval / RAGAS Faithfulness	Faithfulness ≥ 0.85
Prompt Regression	PromptFoo	Golden Q&A dataset — no degradation vs baseline
LLM Tracing	LangSmith	Full chain traces, latency profiling, error diagnosis
Performance Testing	Locust / k6	Embedding API P95, vector search P95, LLM P95 ≤ 3s
Security Testing	Custom + OWASP	Prompt injection, PII leakage, OWASP LLM Top 10
UI / E2E Testing	Playwright	Chat interface, user workflows, accessibility (WCAG)

Recommended Test Folder Structure

tests/
├── data/
│   ├── test_ingestion.py        # All source docs ingested
│   ├── test_chunking.py         # No empty or duplicate chunks
│   └── test_metadata.py         # Source, page, date correct
├── embeddings/
│   ├── test_embedding_dim.py    # Vector shape correct
│   └── test_similarity.py       # Semantic similarity scores
├── retrieval/
│   ├── test_ragas_precision.py  # Context Precision >= 0.80
│   └── test_ragas_recall.py     # Context Recall >= 0.75
├── llm/
│   ├── test_faithfulness.py     # Hallucination detection
│   ├── test_relevance.py        # Answer relevance
│   └── test_promptfoo.py        # Golden Q&A regression
└── security/
    ├── test_prompt_injection.py  # Injection blocked
    └── test_pii_leakage.py       # No PII in responses

Series Summary — 9 Principles to Remember

1. RAG is the enterprise standard. Private data + LLM = grounded, accurate answers. No retraining needed.
2. Every pipeline stage needs testing. Ingest → Chunk → Embed → Store → Retrieve → Generate — each can fail independently.
3. Chunking quality determines retrieval quality. 512 tokens + 10% overlap is your safe default. Invest time tuning this.
4. Never switch embedding models without re-indexing. It will silently break your entire retrieval layer.
5. RAGAS is non-negotiable. Context Precision + Recall measure retrieval. Faithfulness + Relevance measure LLM output.
6. CI/CD for RAG is mandatory. Every document change can silently break retrieval. Automate your quality gate.
7. Choose cloud by ecosystem. Microsoft shop → Azure. Multi-model → AWS. Oracle DB customers → OCI.
8. Security testing for LLMs is different. OWASP LLM Top 10 is your checklist. Prompt injection is your highest risk.
9. Monitoring never stops. Set up continuous RAGAS evaluation in production. Drift is silent and inevitable.

References

• RAGAS — https://docs.ragas.io
• DeepEval — https://docs.confident-ai.com
• PromptFoo — https://promptfoo.dev
• LangSmith — https://smith.langchain.com
• Azure AI Search — https://learn.microsoft.com/en-us/azure/search/
• AWS Bedrock — https://docs.aws.amazon.com/bedrock
• Oracle AI Vector Search — https://docs.oracle.com/en/database/oracle/oracle-database/23/vecse/
• OWASP LLM Top 10 — https://owasp.org/www-project-top-10-for-large-language-model-applications/

The post How to Test a RAG System: RAGAS, Hallucination Detection, and the Complete GenAI CI/CD Pipeline appeared first on Perficient Blogs.

Snowflake Horizon Catalog is designed to help solve these challenges. By transforming metadata into an active layer of business intelligence, Horizon Catalog helps organizations improve data discovery, governance, analytics adoption, and AI readiness. 

Currently in private preview, Horizon Catalog represents Snowflake’s vision for creating a unified understanding of enterprise data across people, applications, analytics tools, and AI agents. 

Why Metadata Matters More Than Ever 

As data ecosystems continue to grow, enterprises often face a common challenge: critical business knowledge is scattered across databases, dashboards, data pipelines, and cloud platforms. 

This fragmentation creates obstacles for both human users and AI systems: 

• Data teams spend excessive time answering questions about data definitions and lineage. 

• Business users struggle to find trusted data assets. 

• Governance teams lack complete visibility into how information moves through the organization. 

• AI applications risk generating inaccurate outputs when business context is unclear. 

Snowflake Horizon Catalog addresses these challenges by creating a centralized intelligence layer that collects, enriches, and activates metadata across the enterprise. Rather than functioning as a passive inventory of assets, Horizon Catalog helps organizations create a living, governed representation of their data ecosystem. 

Horizon Catalog’s Three-Stage Approach 

At its core, Horizon Catalog follows a three-stage architecture designed to transform raw metadata into actionable business context: 

Collect → Enrich → Activate 

This framework enables organizations to move beyond simply documenting data and toward making it truly understandable and usable across analytics and AI workloads. 

Stage 1: Collect Metadata Across the Enterprise 

The first step is collecting metadata from across the modern data landscape. 

Organizations today operate across numerous systems, including cloud storage platforms, SaaS applications, databases, business intelligence tools, and transformation frameworks. Without a unified approach to metadata collection, visibility becomes fragmented and governance becomes increasingly difficult. 

Horizon Catalog connects to a broad ecosystem of technologies, including: 

Data Lakes and Cloud Storage 

• AWS S3 

• Azure Data Lake Storage 

• Google Cloud Storage 

• Iceberg, Delta, and Parquet-based environments 

Enterprise Applications 

• SAP 

• Salesforce 

• Workday 

Databases 

• PostgreSQL 

• SQL Server 

• Oracle 

• MySQL 

• Amazon Redshift 

Analytics and Data Integration Tools 

• Tableau 

• Power BI 

• dbt 

• Fivetran 

• Sigma 

By bringing metadata into a centralized framework, organizations gain a consistent view of data assets regardless of where they reside. For enterprise leaders pursuing AI initiatives, this unified visibility becomes increasingly important as data sources continue to multiply. 

Stage 2: Enrich Metadata With Business and Technical Intelligence 

Collecting metadata is only the beginning. To make data useful at scale, organizations need additional context that helps explain how information is structured, governed, consumed, and connected. 

Horizon Catalog enriches metadata across six key dimensions: 

Schema Intelligence 

Schema enrichment captures structural details such as column types, relationships, and dependencies, providing foundational understanding of data assets. 

Lineage Visibility 

Cross-platform, column-level lineage helps teams understand how data moves from source systems through transformations and ultimately into dashboards, reports, and applications. This visibility supports governance, troubleshooting, compliance, and impact analysis efforts across the organization. 

AI-Generated Descriptions 

Natural language descriptions help make technical assets easier to understand for both business and technical stakeholders. This capability can significantly improve self-service adoption by reducing reliance on tribal knowledge. 

Tags and Classifications 

Business and technical metadata can be categorized using governance tags and classifications, helping organizations improve discovery, compliance, and policy enforcement. 

Popularity and Usage Insights 

Understanding how datasets are used provides valuable context around adoption, trust, and business value. Usage signals help teams identify high-value assets and prioritize governance efforts accordingly. 

Semantic Views 

Semantic views create business-friendly abstractions on top of physical data structures. By establishing shared business definitions, organizations can reduce reporting inconsistencies and improve alignment across analytics initiatives. 

Stage 3: Activate Context Across Analytics and AI 

The true value of Horizon Catalog emerges when enriched metadata is activated across the organization. Many traditional catalogs stop at documentation. Horizon Catalog extends beyond that model by making context available directly within analytics workflows and AI-powered experiences. This activation layer is enabled through Horizon Context, which helps ensure that data consumers and AI systems have access to trusted enterprise knowledge when making decisions. 

Potential downstream applications include: 

• Snowflake CoCo 

• Snowflake CoWork 

• Cortex Agents 

• Business intelligence platforms 

• Custom applications and experiences 

As enterprises move toward AI-assisted decision-making, the ability to ground AI interactions in governed business context becomes increasingly critical. Organizations that can provide consistent definitions, lineage, and governance information to AI models will be better positioned to generate reliable outcomes while maintaining trust in AI-generated insights. 

Horizon Context: The Foundation for Enterprise AI 

One of the most significant aspects of Horizon Catalog is Horizon Context, which serves as an active context layer for analytics and AI solutions. 

Key capabilities include: 

Level-of-Detail Expressions 

Organizations can define metrics at multiple levels of granularity without creating redundant data structures. 

Composable Semantics 

Reusable semantic components allow teams to build business logic efficiently while maintaining consistency across reporting and analytics experiences. 

User-Defined Materializations 

Performance optimization techniques allow expensive calculations to be cached while maintaining freshness requirements. 

Semantic Studio 

A visual workspace enables teams to build, manage, and govern semantic views across the organization. 

Semantic View Autopilot 

AI-assisted tools help accelerate semantic model development by generating business context directly from table structures. Together, these capabilities help bridge the longstanding gap between technical data models and business understanding. 

Improving Data Discovery Through Intelligent Search 

Finding the right data remains one of the most persistent challenges facing modern organizations. Horizon Catalog addresses this challenge through a hybrid search approach that combines multiple discovery mechanisms: 

Keyword Search 

Traditional search capabilities support users who know exactly what they are looking for. 

Semantic Search 

Vector-based search enables discovery based on meaning rather than exact terminology, helping users uncover related assets they may not have known existed. 

Intelligent Re-Ranking 

Machine learning-powered relevance scoring evaluates factors such as user context, popularity, and asset freshness to surface the most useful results. For organizations seeking to increase self-service analytics adoption, improved discoverability can significantly reduce the time required to locate trusted data assets. 

Expanding Metadata Intelligence Through Select Star 

Snowflake’s partnership with Select Star highlights a growing enterprise need for metadata management that extends beyond a single platform. 

The collaboration introduces capabilities such as: 

• Unified metadata visibility across multiple technologies 

• Cross-platform lineage tracking 

• Column-level impact analysis 

• Enhanced user experiences for both business and technical users 

• Integration with Snowflake AI workflows 

As organizations continue adopting multi-platform architectures, the ability to establish consistent governance and visibility across ecosystems becomes increasingly important. 

What This Means for Enterprise Data Leaders 

From a strategic perspective, Horizon Catalog represents more than another data governance tool. It reflects a broader shift in how organizations think about metadata. Historically, metadata was viewed primarily as documentation. Today, metadata is becoming a foundational asset for AI readiness, business intelligence, data governance, and self-service analytics. 

Organizations that can effectively collect, govern, and activate metadata will be better positioned to: 

• Scale AI initiatives with confidence 

• Improve data quality and trust 

• Accelerate analytics adoption 

• Strengthen governance and compliance efforts 

• Reduce time spent searching for and validating data 

• Create consistent business definitions across teams 

Perficient’s Perspective 

At Perficient, we see Horizon Catalog as an important evolution in the enterprise data management landscape. As organizations invest in generative AI, data products, and modern analytics platforms, trusted context becomes just as important as the data itself. Business leaders need confidence that AI systems are grounded in governed, accurate, and explainable information. Snowflake Horizon Catalog helps address this challenge by turning metadata into an active intelligence layer that supports both human decision-making and AI-powered experiences. 

For organizations pursuing enterprise-scale AI, this shift from passive governance to active context management may become a critical component of building a trusted, scalable data foundation. 

Ready to Build an AI-Ready Data Foundation? 

Perficient helps organizations maximize their Snowflake investments through modern data architecture, governance, analytics, and AI strategy services. Whether you’re exploring Horizon Catalog, strengthening your data governance framework, or scaling enterprise AI initiatives, our experts can help you create the trusted data foundation needed to drive measurable business outcomes. Learn more about Perficient’s Snowflake practice.  

The post Snowflake Horizon Catalog: Transforming Metadata Into Business Context for the AI Era appeared first on Perficient Blogs.

The conversation has moved beyond whether AI has potential. Most organizations already understand the opportunity. The real challenge is turning AI investments into measurable business outcomes. 

That’s where many companies get stuck. 

Not because they lack technology or ideas, but because the traditional delivery model can’t keep pace with the speed today’s business environment demands.  

Too many Salesforce initiatives take longer than expected, cost more than planned, and delay value realization. AI may have changed what’s possible, but many organizations are still implementing Salesforce the same way they did five years ago. 

At a time when executive teams are demanding faster ROI, that approach no longer works. 

A Different Era of Salesforce Delivery  

At Perficient, we believe the biggest opportunity in AI isn’t simply building AI-powered experiences. It’s transforming how those experiences get delivered. 

That’s why we’ve fundamentally reimagined our Salesforce delivery model around AI.  

Rather than adding AI to existing processes, we’ve embedded agentic intelligence throughout the software development lifecycle, accelerating discovery, design, development, testing, and deployment. 

The result isn’t incremental improvement but a fundamentally different way to delivery Salesforce transformation. 

Organizations experience the difference from Day 1: 

• Lower cost, with predictable engagement models focused on outcomes rather than hours. In one recent engagement, our approach helped a technology client avoid more than $1M in anticipated services costs. 
• Faster time to value, with delivery timelines accelerated by 30-50%. 
• Proven business impact, accelerating everything from proposal development to implementation and helping clients realize value sooner. 

This is why Perficient has become the Salesforce partner organizations turn to when speed, cost, or complexity are on the table. 

When executive expectations are high. When timelines are aggressive. When AI initiatives need to move beyond pilots and into production. When enterprise complexity threatens to slow progress. 

We help organizations move from vision to value without compromising the governance, scalability, or sophistication required by global enterprises.  

The Next Frontier: Accelerating Business Outcomes 

Technology alone doesn’t create competitive advantage. The ability to implement, scale, and operationalize it does. 

Because we’ve transformed how Salesforce gets delivered, we’re able to help clients tackle some of their most important business priorities faster, whether that’s deploying production-ready Agentforce experiences, modernizing revenue operations, or activating customer data to power more personalized engagement across channels. 

Our expertise spans the Salesforce platforms where organizations are making their biggest investments and expecting their biggest returns. 

Building the Agentic Front Office 

One example of that vision is what we call the Agentic Front Office.  

We believe organizations are entering a new era where employees spend less time navigating systems and more time directing outcomes. 

Instead of manually searching for information, triggering workflows, or coordinating across disconnected platforms, AI agents will orchestrate much of that work behind the scenes. Salesforce evolves from a system of record into an intelligence and orchestration layer that provides marketing, sales, and service interactions.  

The result is a front office that can move faster, respond smarter, and create more personalized experiences throughout the customer lifecycle. 

Headless 360: Reimagining the Experience Layer 

We’re also helping organizations rethink where those experiences live.  

As a Salesforce Headless 360 Launch Partner, Perficient helps clients design customer experiences around users, workflows, and AI agents rather than traditional application boundaries.  

The question is no longer, “What systems should users work in?” It’s become “What’s the fastest path to the right outcome?” 

Whether that experience happens inside Salesforce, a custom application, or a digital channel, Salesforce serves as the data, workflow, and orchestration engine that powers it all. 

See the Difference at Dreamforce 

This year, our Dreamforce story isn’t simply about AI.  

It’s about what happens when AI transforms how Salesforce gets delivered and helping organizations move from idea to implementation faster, reducing the time between investment and value, and proving there’s a better way to build, scale, and optimize Salesforce in the age of AI. 

If you’re looking for a partner that can help you accelerate outcomes, reduce complexity, and operationalize AI at enterprise scale, we’d love to show you what’s possible. Because the future isn’t just AI-powered experiences – the future is AI-powered delivery. And that future is already here.  

Connect with us at Dreamforce at one of our various events or speaking engagements: 

• Executive Strategy Sessions & Client Meetings | Available throughout Dreamforce  
• Welcome Reception | Monday, September 14 
• Agentforce Champions Breakfast Panel | Tuesday, September 15 
• TMT Happy Hour | Tuesday, September 15 
• Demo Open House | Wednesday, September 16 
• TMT Commercial Pre-Dreamfest Happy Hour | Wednesday, September 16
• Agentic Front Office From Pilot to Scale with Agentforce Session | Thursday, September 17 

The post The Future of Salesforce Isn’t Just AI. It’s How AI Changes Delivery. appeared first on Perficient Blogs.

Two Very Different Approaches to Enterprise RAG

In Part 3, we covered Azure — the natural choice for Microsoft-heavy enterprises. Today we explore two more platforms: AWS Bedrock and Oracle Cloud Infrastructure (OCI). Each has a distinct architectural philosophy and a clear ‘best fit’ use case.

AWS Bedrock: Maximum flexibility. The broadest model catalog in the industry. Built for teams that want to experiment with multiple LLMs and use managed services to minimize operational overhead.

OCI Vector Search: Maximum efficiency for Oracle customers. Native vector support directly in Oracle Database 23ai — no separate vector database needed. SQL-native vector queries from day one.

Choosing a cloud for RAG is not about which is ‘best’. It is about which fits your existing infrastructure, team skills, and cost model.

AWS Implementation — Amazon Bedrock + OpenSearch

AWS Services

AWS Architecture Flow

• Documents in S3 trigger a Lambda function via S3 Event Notification
• AWS Step Functions orchestrates the pipeline: Extract → Chunk → Embed → Store
• Chunking Lambda uses LangChain RecursiveCharacterTextSplitter (512 tokens, 50-token overlap)
• Amazon Bedrock Titan Embeddings V2 generates a 1024-dim vector per chunk
• OpenSearch k-NN index stores chunk text + vector + metadata using HNSW algorithm
• RAG app (Lambda + API Gateway): embed query → OpenSearch k-NN → build prompt → call Bedrock Claude → return answer
• CloudWatch captures all logs, latency metrics, and fires alerts on anomalies

AWS Bedrock — The Multi-Model Advantage

The biggest differentiator of AWS Bedrock is its model catalog. No other platform offers this breadth through a single unified API:

Bedrock lets you A/B test different LLMs with zero infrastructure changes. Switch Claude to Llama by changing one line — the API contract stays identical.

Bedrock Knowledge Bases — Managed RAG

For teams that want to move fast, AWS Bedrock Knowledge Bases is the fastest path to production RAG:

• Point it at an S3 bucket — AWS handles chunking, embedding, and OpenSearch automatically
• No infrastructure to manage — fully serverless, auto-scaling
• Integrated with all Bedrock LLMs — one API call returns a grounded answer with citations
• Trade-off: less control over chunking strategy, embedding model, and retrieval tuning

Use the managed option for prototypes and internal tools. Use the custom Lambda + OpenSearch path for production systems where retrieval quality tuning is critical.

AWS CodePipeline Testing

OCI Implementation — Oracle Database 23ai as Your Vector DB

Oracle Cloud Infrastructure takes a fundamentally different approach. Instead of adding a new vector database service alongside your existing infrastructure, OCI embeds vector capabilities directly into Oracle Database 23ai.

If your enterprise already runs Oracle ERP, Oracle databases, or Oracle Fusion middleware — you already have a production-grade vector database. You just need to enable it.

OCI Services

OCI Architecture Flow

• Documents uploaded to OCI Object Storage trigger an OCI Function via OCI Events Service
• Function extracts text and sends to chunking logic (Python-based splitter)
• OCI Generative AI Embed Models generate 1024-dim vector per chunk
• Chunk text + vector stored directly in Oracle DB 23ai using the native VECTOR column type
• RAG app: embed query → SQL VECTOR_DISTANCE() search → build prompt → call OCI GenAI → return answer

OCI’s Killer Feature — SQL-Native Vector Search

This is what makes OCI genuinely unique. Vector search in Oracle DB 23ai is just a SQL query:

SELECT chunk_text,

       VECTOR_DISTANCE(embedding, :query_vector, COSINE) AS similarity_score

FROM   documents_chunks

WHERE  category = 'HR'

ORDER  BY similarity_score

FETCH  FIRST 5 ROWS ONLY;

Notice the WHERE clause — you can combine traditional SQL filters with vector similarity in a single query. This enables hybrid filtering that other vector databases require complex workarounds to achieve.

AWS vs OCI — Side-by-Side Comparison

  In Part 5 — the final post — we cover the full testing strategy for RAG systems: the 4-layer testing pyramid, RAGAS metrics, hallucination detection, and the complete GenAI CI/CD pipeline.

The post RAG on AWS Bedrock vs Oracle Cloud: Architecture, Trade-offs, and When to Choose Each appeared first on Perficient Blogs.