ML models learn non-linear patterns that classical statistics can't capture. Result: 30-50% more accurate forecasting for high-seasonality products.

Demand Forecasting Architecture

Required data (what you already have):

Recommended models by context:

MAPE = Mean Absolute Percentage Error. Lower is better.

Practical Implementation: From Zero to Working Model

Phase 1: Data Preparation (4-6 weeks)

Data quality checklist for demand forecasting:

[ ] Export daily sales history by SKU from the last 24 months from ERP
[ ] Identify and handle outliers (strikes, pandemics, system errors)
[ ] Map stockout periods (when actual demand was suppressed)
[ ] Categorize products by behavior (seasonal, trend-based, stable, long tail)
[ ] Create event calendar: holidays, campaigns, industry seasonality
[ ] Validate that inventory data matches sales (no unexplained gaps)
[ ] Document price changes and their historical impact

Phase 2: Model Development (4-8 weeks)

For companies without an in-house data science team, there are three paths:

Prompt for ChatGPT/Claude to start seasonality analysis:

Analyze the sales data below and identify seasonality patterns.

DATA (CSV format):
date,sku,quantity_sold,average_price,category
[INSERT YOUR DATA -- can be a 6-month subset]

REQUESTED ANALYSIS:
1. Identify weekly seasonality (which days of the week sell more)
2. Identify monthly seasonality (which months have peaks and valleys)
3. List the 5 SKUs with highest demand variability (hardest to forecast)
4. List the 5 most stable SKUs (easiest to automate)
5. Identify any anomalies in the data (days with zero sales, unexplained spikes)
6. Recommend the most suitable forecasting model for each product category

Format: tables and ASCII charts where possible. Insights in objective bullets.

Real-World Demand Forecasting Cases in Brazil

Magazine Luiza (Magalu)

Magalu implemented demand forecasting models in 2021 as part of their digital transformation. Documented results:

• 19% reduction in average inventory levels without increasing stockouts
• 23% improvement in forecast accuracy for seasonal products
• R$ 340 million reduction in working capital tied up in inventory

The model uses more than 200 variables, including macroeconomic data, social media history, Google Trends search trends, and regional weather data.

Localfrio

Localfrio, specializing in refrigerated storage, implemented ML-based warehouse occupancy forecasting. With extremely seasonal cold storage demand (Christmas, Easter, June festivals), the model reduced capacity idle time by 27% and enabled 15% more profitable spot capacity contracts.

Part 2: Route Optimization with OR-Tools and AI

Route planning is the most classic logistics problem — and also where the gap between manual approaches and computational optimization is most dramatic.

The Traveling Salesman Problem (And Why It's Hard)

Finding the best route for 10 stops seems simple. But with 10 stops, there are 3,628,800 possible sequences. With 20 stops, you're looking at 2 quintillion options. No human, spreadsheet, or GPS solves this optimally in real time.

Algorithms Used in Practice:

Implementation with OR-Tools (Google)

OR-Tools is Google's open-source library for combinatorial optimization problems. It's free, robust, and used by companies the size of DHL and Walmart.

Basic Installation and Setup:

# Install OR-Tools
pip install ortools

# Import and configure basic routing problem
from ortools.constraint_solver import routing_enums_pb2
from ortools.constraint_solver import pywrapcp

def create_routing_model(data):
    """
    data = {
        'distance_matrix': list of lists (distance in meters between each pair of points),
        'num_vehicles': number of available vehicles,
        'depot': starting point index (usually 0),
        'vehicle_capacity': [list of capacity for each vehicle in kg],
        'customer_demand': [list of demand for each customer in kg]
    }
    """
    manager = pywrapcp.RoutingIndexManager(
        len(data['distance_matrix']),
        data['num_vehicles'],
        data['depot']
    )

    routing = pywrapcp.RoutingModel(manager)

    # Distance function
    def distance_callback(from_index, to_index):
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return data['distance_matrix'][from_node][to_node]

    transit_callback_index = routing.RegisterTransitCallback(distance_callback)
    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

    # Capacity constraint
    def demand_callback(from_index):
        from_node = manager.IndexToNode(from_index)
        return data['customer_demand'][from_node]

    demand_callback_index = routing.RegisterUnaryTransitCallback(demand_callback)
    routing.AddDimensionWithVehicleCapacity(
        demand_callback_index,
        0,  # no slack
        data['vehicle_capacity'],
        True,  # start cumulative from zero
        'Capacity'
    )

    # Search parameters
    params = pywrapcp.DefaultRoutingSearchParameters()
    params.first_solution_strategy = (
        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
    )
    params.local_search_metaheuristic = (
        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
    )
    params.time_limit.FromSeconds(30)  # 30 seconds to optimize

    solution = routing.SolveWithParameters(params)
    return routing, manager, solution

Common Constraints in Brazil:

# Time window constraint (e.g., customer only receives between 8am and 12pm)
def add_time_windows(routing, manager, time_windows):
    """
    time_windows = [(start_minutes, end_minutes)] for each point
    Example: [(480, 720)] = from 8am (480 min) to noon (720 min)
    """
    def time_callback(from_index, to_index):
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return time_matrix[from_node][to_node]  # time in minutes

    time_callback_index = routing.RegisterTransitCallback(time_callback)

    routing.AddDimension(
        time_callback_index,
        30,   # maximum waiting tolerance in minutes
        1440, # maximum route duration (24 hours)
        False,
        'Time'
    )

    time_dimension = routing.GetDimensionOrDie('Time')
    for location_idx, time_window in enumerate(time_windows):
        if location_idx == 0:
            continue  # skip depot
        index = manager.NodeToIndex(location_idx)
        time_dimension.CumulVar(index).SetRange(
            time_window[0], time_window[1]
        )

SaaS Alternatives for Those Who Don't Want to Code

Typical Gains from AI-Powered Route Planning:

Part 3: Predictive Inventory Management

The True Cost of Inventory in Brazil

Holding inventory in Brazil is expensive. High Selic rates mean significant opportunity costs (capital sitting idle). Inflation erodes the value of unsold products. Theft and damage during transport affect between 0.5% and 3% of inventory.

Total Cost of Ownership for Inventory:

An inventory worth R$10 million costs between R$1.4 and R$2.6 million per year just to maintain. Reducing stock levels by 20% without increasing stockouts generates R$280,000–520,000 in annual savings.

AI-Powered Replenishment Policies

Current policy at most companies: Fixed reorder point (when inventory reaches X units, order Y units). This works for stable products in a predictable environment. It fails in everything else.

What AI enables:

Dynamic Replenishment Policy Based on ML:

Instead of: "Order when you hit 100 units, order 300 units"
AI calculates: "Given the demand forecast for the next 2 weeks,
                the current supplier lead time (4.2 days),
                this supplier's historical variability (±1.5 days),
                and the desired service level (95%),
                today's reorder point is 187 units
                and the replenishment lot size is 423 units."

It recalculates this every single day.

Prompt for inventory policy analysis:

Analyze the current inventory policy and recommend improvements based on data.

PRODUCT DATA:
- SKU: [CODE]
- Category: [CATEGORY]
- Average daily demand: [NUMBER] units
- Standard deviation of daily demand: [NUMBER] units
- Supplier lead time: [NUMBER] days (average)
- Lead time variability: [NUMBER] days (standard deviation)
- Unit cost: R$ [VALUE]
- Ordering cost: R$ [VALUE] (cost of placing an order -- freight, processing)
- Stockout cost: R$ [VALUE] per unit (lost sales or penalties)
- Desired service level: [98%]
- Current reorder point: [NUMBER] units
- Current replenishment lot size: [NUMBER] units

CALCULATE:
1. Optimal safety stock (formula: SS = Z × σd × sqrt(L) where Z is the service level factor)
2. Optimal reorder point (formula: ROP = d × L + SS)
3. Economic order quantity (EOQ formula)
4. Current total policy cost (tied-up capital + stockouts + orders)
5. Total cost of optimized policy
6. Estimated annual savings

Show all formulas and calculations step by step.

ABC-XYZ Classification to Prioritize Automation

Before automating everything, prioritize. The ABC-XYZ matrix identifies which SKUs deserve the most attention:

Prompt for automated classification:

Classify the products below using the ABC-XYZ matrix.

DATA (CSV):
sku,annual_revenue,demand_variation_coefficient
[PASTE YOUR DATA]

ABC:
- A = top 80% of revenue
- B = next 15% of revenue
- C = bottom 5% of revenue

XYZ (by coefficient of variation = standard deviation / mean):
- X = CV < 0.5 (predictable demand)
- Y = CV between 0.5 and 1.0 (moderately variable demand)
- Z = CV > 1.0 (highly variable demand)

For each group, recommend:
1. Appropriate replenishment policy
2. Target service level
3. Review frequency
4. Candidates for portfolio elimination (CZ with low margins)

Part 4: Tax Documentation Automation

Brazil has one of the world's most complex tax legislation systems. Generating, validating, and storing tax documents (NF-e, NFS-e, CT-e, MDF-e, DANFE) consumes significant time and creates costly errors.

The Problem with Manual Tax Documentation

AI for Pre-Issuance NF-e Validation

Before issuing an NF-e, AI automatically validates the data:

# Example of validation rules with AI
import anthropic

client = anthropic.Anthropic()

def validate_nfe_pre_issuance(nfe_data: dict) -> dict:
    """
    Validates NF-e data before transmitting to SEFAZ.
    Returns a list of errors and warnings.
    """

    prompt = f"""
    You are an expert in Brazilian tax legislation, specifically in NF-e.

    Validate the NF-e data below before issuance.

    NF-E DATA:
    CFOP: {nfe_data.get('cfop')}
    CST/CSOSN: {nfe_data.get('cst')}
    NCM: {nfe_data.get('ncm')}
    Origin State: {nfe_data.get('uf_emitente')}
    Destination State: {nfe_data.get('uf_destinatario')}
    Operation type: {nfe_data.get('tipo_operacao')}  # sale, transfer, shipment, etc.
    Total value: R$ {nfe_data.get('valor_total')}
    ICMS rate applied: {nfe_data.get('icms_aliquota')}%
    PIS rate: {nfe_data.get('pis_aliquota')}%
    COFINS rate: {nfe_data.get('cofins_aliquota')}%

    CHECK:
    1. Is the CFOP correct for the described operation type?
    2. Is the ICMS rate correct for this origin state -> destination state?
    3. Does the aliquot differential (DIFAL) apply? If yes, is it calculated?
    4. Is the NCM valid and consistent with the product description?
    5. Is the CST/CSOSN compatible with the issuer's tax regime?
    6. Is there any tax substitution to consider for this operation?

    Return in JSON format:
    {{
      "status": "approved" | "reject" | "warnings",
      "critical_errors": [],  // prevent issuance
      "warnings": [],         // may cause problems later
      "recommendations": []   // best practices
    }}
    """

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    )

    return response.content[0].text

CT-e and MDF-e Automation for Carriers

For carriers and shippers, CT-e and MDF-e are mandatory. The manual process is error-prone.

Prompt for CT-e verification:

Analyze the electronic transport waybill (CT-e) information below and identify inconsistencies or tax risks.

CT-E DATA:
- Service purchaser: [WHO PAYS — shipper, receiver, expeditor, or consignee]
- CFOP: [CODE]
- Mode: [GROUND / AIR / RAIL / WATER]
- Origin state: [STATE]
- Destination state: [STATE]
- Service value: R$ [VALUE]
- Calculated ICMS: R$ [VALUE] ([RATE]%)
- Service type: [CIF / FOB / OTHER]
- Linked NF-e: [LIST OF KEYS]

CHECK:
1. Is the CFOP correct for the mode and service type?
2. Is the ICMS rate for transport services correct (ICMS-T)?
3. Is the purchaser correct based on the freight condition (CIF = shipper pays, FOB = receiver pays)?
4. Is there a state registration restriction for the carrier in the origin state?
5. Will an MDF-e be required? (yes for more than 1 CT-e or more than 1 unloading municipality)
6. Recommendations to avoid rejection by SEFAZ?

Brazilian Tax Automation Tools

For mid-sized companies with high volume, combining an issuance API (NFe.io or Focus NF-e) with AI-powered pre-issuance validation reduces rejections by 85–95%.

Part 5: AI-Powered Fleet Monitoring

The Brazilian Fleet Reality

AI for Predictive Maintenance

Predictive maintenance uses sensors and ML to forecast when a vehicle will experience a failure before it actually happens.

How it works:

Data collected continuously:
- Engine temperature
- Oil pressure
- Engine vibration (accelerometer)
- Fuel consumption per km
- Brake temperature
- Odometer and hour meter

ML model compares current pattern with:
- Vehicle's own history
- History of similar vehicles in the fleet
- Database of historical failures

Result:
- "Vehicle plate ABC-1234: 87% probability of cooling system failure in the next 15 days"
- "Recommendation: schedule inspection in 7 days for radiator and coolant inspection"

Prompt for telemetry data analysis:

Analyze the telemetry data from the vehicle below and identify maintenance risks.

VEHICLE DATA:
Model: [MODEL]
Year: [YEAR]
Odometer: [KM]
Last service: [DATE] at [KM]

TELEMETRY FROM THE LAST 30 DAYS:
- Average engine temperature: [X] degrees (normal: 85-95)
- Engine temperature peak: [X] degrees
- Average consumption: [X] l/100km (historical: [X] l/100km)
- Hard braking events: [X] per day (fleet average: [X])
- Hard acceleration events: [X] per day
- Hours with engine running idle: [X] hours/day
- OBD system alerts: [LIST OF DTC CODES IF ANY]

ANALYSIS:
1. Which indicators are outside normal parameters?
2. What component has the highest failure risk in the next 30 days?
3. What is the maintenance urgency (can wait for next service / schedule within 2 weeks / urgent)?
4. Estimated financial impact if failure occurs in the field vs. if corrected preventively?
5. Checklist of items for the next service based on this data?

Telemetry Platforms Available in Brazil

Part 6: Supplier Analysis with AI

Supply chain risk in Brazil

Relying on concentrated suppliers is one of the biggest supply chain risks. The 2018 trucker strike showed how a single point of failure can halt operations for weeks.

AI-powered supplier evaluation framework:

Evaluate the supplier below using supply chain risk management criteria.

SUPPLIER:
Name: [NAME]
Product/service provided: [DESCRIPTION]
Share of total spend: [X]%
Number of alternative suppliers available: [X]
Country of origin: [COUNTRY]

HISTORICAL DATA:
- On-Time Delivery (OTD) past 12 months: [X]%
- Quality index (returns / total): [X]%
- Price fluctuation over the year: [X]%
- Number of delay incidents > 5 days: [X]
- Average lead time: [X] days
- Maximum recorded lead time: [X] days

CONTEXT:
- Currency exposure: [yes/no and how much]
- Dependency on specific input: [describe if relevant]
- Certifications: [ISO, ANVISA, etc.]
- Financial situation (if available): [cash flow, debt, rating]

GENERATE:
1. Risk score (1-10, where 10 is highest risk) with justification per dimension
2. Top 3 specific risks for this supplier
3. Recommended mitigation actions for each risk
4. Watchlist criteria (what to monitor weekly)
5. Diversification recommendation: is it worth having a second supplier?

Automating supplier monitoring

# AI-powered automatic supplier monitoring script
import anthropic
import pandas as pd
from datetime import datetime, timedelta

def monitor_supplier(supplier_data: dict, delivery_history: pd.DataFrame) -> str:
    """
    Analyzes supplier performance and generates alerts if needed.
    Runs daily for each critical supplier.
    """

    # Calculate metrics from the last 30 days
    last_30_days = delivery_history[
        delivery_history['delivery_date'] >= datetime.now() - timedelta(days=30)
    ]

    otd = (last_30_days['delivered_on_time'].sum() / len(last_30_days)) * 100
    quality = (last_30_days['no_returns'].sum() / len(last_30_days)) * 100
    avg_lead_time = last_30_days['lead_time_days'].mean()

    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"""
            Analyze supplier {supplier_data['name']}'s performance over the last 30 days:

            OTD (On-Time Delivery): {otd:.1f}% (target: {supplier_data['target_otd']}%)
            Quality (no returns): {quality:.1f}% (target: {supplier_data['target_quality']}%)
            Average lead time: {avg_lead_time:.1f} days (contractual: {supplier_data['contractual_lead_time']} days)

            Is the supplier meeting targets? If not, what is the severity and what action should be taken?
            Respond in 3 lines: status, main issue, recommended action.
            """
        }]
    )

    return response.content[0].text

Part 7: Integration with Brazilian ERPs

The challenge of integrating AI with legacy Brazilian systems

Most Brazilian companies use national ERPs (TOTVS Protheus, SAP Business One, Omie, Senior, Sankhya) that were built before the ML era. Integrating AI into these systems requires a strategic approach.

Integration approaches:

TOTVS Protheus: practical integration

Protheus is the most widely used ERP in medium and large companies in Brazil. It has a REST API starting from version 12.

# Example of extracting data from Protheus for ML analysis
import requests
import pandas as pd

class ProtheusConnector:
    def __init__(self, base_url: str, username: str, password: str):
        self.base_url = base_url
        self.session = requests.Session()
        self.session.auth = (username, password)
        self.session.headers.update({
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        })

    def get_movimentos_estoque(self, data_inicio: str, data_fim: str) -> pd.DataFrame:
        """
        Extracts stock movements from Protheus for demand analysis.
        """
        endpoint = f"{self.base_url}/api/framework/v1/queuemanager"

        # SQL query via Protheus REST
        payload = {
            "query": f"""
                SELECT
                    D1_FILIAL,
                    D1_DOC,
                    D1_SERIE,
                    D1_EMISSAO,
                    D1_COD as SKU,
                    B1_DESC as DESCRIPTION,
                    D1_QUANT as QUANTITY,
                    D1_TOTAL as TOTAL_VALUE,
                    D1_CF as CFOP,
                    D1_TIPO as MOVEMENT_TYPE
                FROM SD1010 (NOLOCK)
                    INNER JOIN SB1010 ON B1_COD = D1_COD AND B1_FILIAL = '01'
                WHERE
                    D1_FILIAL = '01'
                    AND D1_EMISSAO BETWEEN '{data_inicio}' AND '{data_fim}'
                    AND D1_TIPO IN ('V', 'E')  -- Sales and Entries
                ORDER BY D1_EMISSAO
            """
        }

        response = self.session.post(endpoint, json=payload)

        if response.status_code == 200:
            dados = response.json()
            return pd.DataFrame(dados['items'])
        else:
            raise Exception(f"Error querying Protheus: {response.status_code}")

    def get_pedidos_compra_abertos(self) -> pd.DataFrame:
        """
        Lists open purchase orders to calculate in-transit inventory.
        """
        endpoint = f"{self.base_url}/api/supply-chain/v1/purchaseOrder"

        response = self.session.get(endpoint, params={
            'status': 'pending,partial',
            'pageSize': 500
        })

        return pd.DataFrame(response.json()['items'])

Omie: automation via native API

Omie has one of the most complete APIs among national ERPs, with specific endpoints for logistics.

# Omie integration for order and inventory automation
import requests

class OmieConnector:
    def __init__(self, app_key: str, app_secret: str):
        self.base_url = "https://app.omie.com.br/api/v1"
        self.app_key = app_key
        self.app_secret = app_secret

    def fazer_chamada(self, endpoint: str, call: str, params: dict) -> dict:
        payload = {
            "call": call,
            "app_key": self.app_key,
            "app_secret": self.app_secret,
            "param": [params]
        }

        response = requests.post(
            f"{self.base_url}/{endpoint}/",
            json=payload
        )
        return response.json()

    def listar_movimentos_estoque(self, data_inicio: str, data_fim: str) -> list:
        """
        Returns stock movements for demand forecasting.
        """
        return self.fazer_chamada(
            "estoque",
            "ListarMovimentos",
            {
                "dDtInicial": data_inicio,  # format DD/MM/YYYY
                "dDtFinal": data_fim,
                "nPagina": 1,
                "nRegPorPagina": 500
            }
        )

    def consultar_posicao_estoque(self, codigo_produto: str) -> dict:
        """
        Queries current stock position of a product.
        """
        return self.fazer_chamada(
            "estoque",
            "ConsultarPosicaoEstoque",
            {"cCodProd": codigo_produto}
        )

SAP Business One: integration via Service Layer

# SAP B1 Service Layer for ML model integration
class SAPB1Connector:
    def __init__(self, server_url: str, company_db: str, username: str, password: str):
        self.base_url = f"{server_url}/b1s/v1"
        self.headers = {'Content-Type': 'application/json'}

        # Login to obtain session
        login_response = requests.post(
            f"{self.base_url}/Login",
            json={
                "CompanyDB": company_db,
                "UserName": username,
                "Password": password
            }
        )

        self.session_cookie = login_response.cookies.get('B1SESSION')
        self.headers['Cookie'] = f"B1SESSION={self.session_cookie}"

    def get_itens_estoque(self, warehouse: str = None) -> pd.DataFrame:
        """
        Extracts stock positions for predictive analysis.
        """
        filter_str = f"$filter=Warehouse eq '{warehouse}'" if warehouse else ""

        response = requests.get(
            f"{self.base_url}/Items?{filter_str}&$select=ItemCode,ItemName,OnHand,MinLevel,MaxLevel,LeadTime",
            headers=self.headers
        )

        return pd.DataFrame(response.json()['value'])

Part 8: Enterprise Supply Chain Tools

For large enterprises requiring comprehensive solutions, specialized platforms are available:

Oracle SCM Cloud

Target audience: Companies with $500M+ in revenue, international operations, and complex supply chains.

Cost: $500,000-3,000,000/year depending on modules and users.

SAP IBP (Integrated Business Planning)

Target audience: Large manufacturers and distributors already using SAP.

AI capabilities:

• Machine learning-powered demand forecasting
• Optimized production planning
• End-to-end inventory visibility (including suppliers)
• Scenario simulation (what if there's a strike? What if a supplier delays?)

Cost: $800,000-5,000,000/year.

Specialized Domestic Solutions

Part 9: Brazilian Case Studies with Documented Results

Sequoia Logistica: Fleet Optimization with AI

Sequoia, one of Brazil's largest logistics operators, deployed AI for fleet routing and monitoring in 2023.

Reported results:

• 18% reduction in fuel cost per delivery
• 27% increase in deliveries per vehicle per day
• 31% reduction in fleet idle time
• Project ROI achieved in under 8 months

Implementation details:

• Dynamic routing algorithm that recalculates routes in real-time based on traffic (integrated with Google Maps Platform)
• Driver behavior scoring (braking, speed, idling)
• Telemetry-based maintenance prediction

B2W (Americanas S.A.): Demand Forecasting in E-commerce

B2W (now Americanas) used ML for demand forecasting prior to the merger. Published results show:

• Demand forecasting accuracy improved from 68% to 84% over 18 months
• Average inventory levels dropped 19% without increasing stockouts
• Stockout rate during Black Friday peak dropped from 12% to 4%
• Estimated savings of $180 million in working capital

Implementation details:

• 200+ variables in the model (including search data, weather, economic indicators)
• Automated replenishment for 60% of portfolio (AX and BX SKUs)
• ML-based Black Friday planning starting 6 months in advance

Magazine Luiza: AI-Integrated Supply Chain

Magalu, a benchmark in digital transformation for Brazilian retail, has published metrics from its logistics transformation:

• Demand forecasting with 30% greater accuracy than traditional methods
• Same-day or next-day delivery for 60% of portfolio in Brazilian state capitals
• Freight costs as a percentage of GMV decreased from 11% to 8.5% over 3 years
• 22% reduction in obsolete inventory

Key differentiators implemented:

• "Smart Fulfillment": algorithm determines which distribution center ships each order based on inventory, freight cost, and promised delivery time
• Regional demand forecasting (popular SKUs in São Paulo differ from those in the Northeast)

Implementation Plan: From Diagnosis to Results

Phase 1: Diagnosis (Weeks 1-4)

Objectives: Identify where the biggest losses occur and prioritize projects with the highest ROI.

Supply Chain Diagnosis Checklist:

INVENTORY:
[ ] Calculate inventory turnover by category (Revenue / Average Inventory)
[ ] Identify top 20 SKUs with the highest tied-up capital
[ ] Assess stockout rate over the past 12 months
[ ] Calculate excess inventory cost (items over 90 days old)

TRANSPORTATION:
[ ] Map freight costs by channel (own fleet vs. third-party vs. postal)
[ ] Calculate on-time delivery rate by carrier
[ ] Assess damage and loss rates by transport mode
[ ] Identify routes with the highest cost per km

SUPPLIERS:
[ ] Calculate OTD (On-Time Delivery) per supplier over the past 12 months
[ ] Identify suppliers with high lead time variability
[ ] Map single-supplier dependency for critical categories

TAX DOCUMENTATION:
[ ] Assess NF-e rejection rate at SEFAZ
[ ] Calculate average time between CT-e issuance and transmission
[ ] Identify fines for delayed or incorrect tax documents

Phase 2: Quick Wins (Weeks 5-12)

Projects that deliver results in 90 days:

Phase 3: ML Projects (Months 4-12)

Projects requiring more data and expertise:

Start with Data, Not the Tool

The most common mistake Brazilian companies make when starting with AI in logistics is prioritizing the tool over the data.

No ML algorithm will accurately forecast demand if the sales history is filled with undocumented stockouts. No routing algorithm will be optimal if real constraints (time windows, vehicle types by region, traffic restrictions) are not in the system.

Clean, well-structured data is worth more than any sophisticated algorithm. Invest in data quality first. The model comes later.

The good news: with the right data, ML models available in 2026 -- many of them open source and free -- deliver results that were exclusive to large corporations just 5 years ago. The democratization of artificial intelligence in supply chain is real, and Brazil is well-positioned to benefit from it.

Next Steps

If you want to implement AI in your company's logistics with structured guidance, templates, and real-world cases:

• Explore AI courses applied to operations -- with modules on demand forecasting, route optimization, and tax automation
• Browse supply chain prompts -- ready-to-use templates for inventory, supplier, and fleet analysis
• Create your free account and start transforming your logistics operations with AI

Companies that take supply chain data seriously don't just cut costs -- they build a competitive advantage that competitors without data will take years to replicate.