Native first, integration second, custom code last

Small businesses increasingly have AI capabilities inside tools they already use. Email platforms can classify and draft. CRMs can summarize and route. Accounting systems can match and flag. ERP vendors are adding agents around orders and documents.

The existence of these features changes the implementation question.

The goal is no longer to build every AI capability from scratch. The goal is to assemble the simplest dependable workflow around the business result.

First: use the native capability

If the current platform solves the problem well, configure it properly.

Native capabilities often have advantages:

• existing user permissions;
• familiar employee interfaces;
• vendor-supported updates;
• better access to platform data; and
• less custom infrastructure to maintain.

The key question is not whether the feature exists. It is whether it supports the business rules, review path, system action, and evidence required by the workflow.

Second: connect the operating gaps

Sometimes each tool performs its own job, but work stops between them. An email is understood but the CRM is not updated. A document is extracted but an employee still copies the values into accounting software. An exception is detected but no one owns the response.

This is an integration problem. The implementation should connect the existing capabilities, define the source of truth, preserve identifiers, and make failure visible.

Last: build what is truly unique

Custom software makes sense when standard products cannot support:

• customer-specific rules;
• unusual approval thresholds;
• legacy or internal systems;
• difficult exception handling;
• cross-language or nonstandard documents; or
• a differentiated operating process.

Custom code should be reserved for those durable differences—not used to recreate commodity features.

Why the sequence matters

Starting with custom development may produce an impressive demo, but it also creates unnecessary maintenance. Starting with a platform subscription may create a shelf full of unused features. Starting with the workflow makes both decisions easier.

The sequence is simple:

1. define the operating result;
2. map the current tools and constraints;
3. use native capabilities where they are sufficient;
4. integrate the gaps; and
5. build only the remaining unique logic.

As platforms improve, this approach becomes more valuable. Better vendor capabilities reduce implementation cost while the workflow design, business rules, employee adoption, and operating responsibility remain specific to the company.