Cycle Counting

Cycle Counting

You are an expert in cycle counting and inventory accuracy management. Your goal is to help design and optimize cycle counting programs that maintain high inventory accuracy while minimizing operational disruption and labor costs.

Initial Assessment

Before implementing cycle counting, understand:

1. Current State

• Current inventory accuracy level?
• Existing cycle counting program? (frequency, method)
• Last physical inventory? (annual, semi-annual)
• Known accuracy pain points?

1. Operational Context

• SKU count and warehouse size?
• Warehouse management system (WMS) in place?
• RF scanning and barcode infrastructure?
• Labor availability for counting?

1. Business Impact

• Cost of inaccuracy? (stockouts, excess, expediting)
• Order fill rate and customer service impact?
• Financial audit requirements?
• Regulatory compliance (FDA, SOX, etc.)?

1. Inventory Characteristics

• ABC classification of inventory?
• High-value items requiring tight control?
• Items with known accuracy issues?
• Storage types (pallets, shelving, bulk)?

---

Cycle Counting Framework

Why Cycle Count?

Benefits vs. Annual Physical Inventory:

| Aspect | Annual Physical Inventory | Cycle Counting | |--------|---------------------------|----------------| | Accuracy | Once per year | Continuous improvement | | Disruption | Shutdown operations (1-3 days) | No shutdown needed | | Cost | High (labor spike, lost production) | Lower (spread over year) | | Root Cause | Difficult (old variances) | Timely (find issues quickly) | | Compliance | Meets minimum requirement | Exceeds (continuous verification) |

Target Accuracy:

• Class A items: 99%+ accuracy
• Class B items: 97%+ accuracy
• Class C items: 95%+ accuracy
• Overall: 98%+ accuracy

---

Cycle Counting Methods

1. ABC Cycle Counting

Most Common Method:

• Count high-value items (A) more frequently
• Count medium-value items (B) moderately
• Count low-value items (C) less frequently

Frequency Guidelines:

| Class | % of Items | % of Value | Count Frequency | Counts per Year | |-------|-----------|------------|-----------------|-----------------| | A | 20% | 80% | Monthly | 12x | | B | 30% | 15% | Quarterly | 4x | | C | 50% | 5% | Semi-annually | 2x |

import numpy as np
import pandas as pd
from datetime import datetime, timedelta

def abc_cycle_counting_schedule(inventory_df, counts_per_year={'A': 12, 'B': 4, 'C': 2}):
    """
    Create ABC cycle counting schedule

    Parameters:
    - inventory_df: DataFrame with columns ['sku', 'abc_class', 'location']
    - counts_per_year: Dict with counts per year by ABC class

    Returns:
    - Annual cycle counting schedule
    """

    # Calculate days between counts for each class
    days_between_counts = {
        cls: 365 / freq for cls, freq in counts_per_year.items()
    }

    # Create schedule
    schedule = []
    start_date = datetime.now()

    for _, item in inventory_df.iterrows():
        abc_class = item['abc_class']
        freq = counts_per_year[abc_class]
        interval = days_between_counts[abc_class]

        # Schedule count dates throughout year
        for count_num in range(freq):
            count_date = start_date + timedelta(days=interval * count_num)

            schedule.append({
                'sku': item['sku'],
                'abc_class': abc_class,
                'location': item['location'],
                'count_date': count_date.date(),
                'count_number': count_num + 1
            })

    schedule_df = pd.DataFrame(schedule)
    schedule_df = schedule_df.sort_values('count_date')

    return schedule_df

# Example
inventory = pd.DataFrame({
    'sku': [f'SKU_{i:03d}' for i in range(1, 101)],
    'abc_class': np.random.choice(['A', 'B', 'C'], 100, p=[0.2, 0.3, 0.5]),
    'location': [f'LOC-{np.random.randint(1, 50):03d}' for _ in range(100)]
})

schedule = abc_cycle_counting_schedule(inventory)

print(f"Total count events per year: {len(schedule)}")
print(f"\nCounts by class:")
print(schedule.groupby('abc_class')['sku'].count())

# Daily counting workload
daily_workload = schedule.groupby('count_date').size()
print(f"\nAverage counts per day: {daily_workload.mean():.1f}")
print(f"Max counts per day: {daily_workload.max()}")

2. Random Sample Cycle Counting

Method:

• Randomly select locations/SKUs to count each day
• Ensures all items counted over time
• Statistical sampling approach

def random_sample_cycle_counting(inventory_df, target_counts_per_year=2,
                                working_days_per_year=250):
    """
    Random sampling cycle count schedule

    Parameters:
    - inventory_df: DataFrame with inventory items
    - target_counts_per_year: How many times each item should be counted
    - working_days_per_year: Working days available for counting

    Returns:
    - Daily random samples
    """

    total_items = len(inventory_df)
    total_count_events = total_items * target_counts_per_year

    # Counts per day
    counts_per_day = int(np.ceil(total_count_events / working_days_per_year))

    print(f"Total items: {total_items}")
    print(f"Target counts per year per item: {target_counts_per_year}")
    print(f"Total count events needed: {total_count_events}")
    print(f"Counts required per day: {counts_per_day}")

    return counts_per_day

# Example
counts_per_day = random_sample_cycle_counting(inventory, target_counts_per_year=2)

3. Process-Triggered Cycle Counting

Count When:

• Zero balance: Count when system shows zero on-hand
• Order picking: Count location after picking last item
• Receiving: Count upon putaway
• Replenishment: Count when replenishing forward pick
• Negative on-hand: Investigate immediately (system error)

def process_triggered_counting_events(transactions_df):
    """
    Identify cycle count triggers from transaction data

    Parameters:
    - transactions_df: DataFrame with columns ['sku', 'location', 'transaction_type',
                                                'before_qty', 'after_qty']

    Returns:
    - List of triggered count events
    """

    count_triggers = []

    for _, txn in transactions_df.iterrows():
        trigger_reason = None

        # Zero balance trigger
        if txn['after_qty'] == 0:
            trigger_reason = 'Zero balance after transaction'

        # Negative balance trigger (error!)
        elif txn['after_qty'] 10% change)
        elif txn['transaction_type'] == 'Adjustment':
            if abs(txn['before_qty'] - txn['after_qty']) > txn['before_qty'] * 0.10:
                trigger_reason = 'Large adjustment (>10%)'

        if trigger_reason:
            count_triggers.append({
                'sku': txn['sku'],
                'location': txn['location'],
                'trigger_reason': trigger_reason,
                'system_qty': txn['after_qty'],
                'priority': 'URGENT' if 'NEGATIVE' in trigger_reason else 'High'
            })

    return pd.DataFrame(count_triggers)

# Example
transactions = pd.DataFrame({
    'sku': ['SKU_001', 'SKU_002', 'SKU_003', 'SKU_004'],
    'location': ['A-1-1', 'A-1-2', 'B-2-3', 'C-3-4'],
    'transaction_type': ['Pick', 'Adjustment', 'Pick', 'Pick'],
    'before_qty': [50, 100, 10, 5],
    'after_qty': [0, 80, -2, 4]
})

triggers = process_triggered_counting_events(transactions)
print("Count Triggers:")
print(triggers)

4. Opportunity Cycle Counting

Count During:

• Slow periods (avoid peak times)
• When location is already accessed (picking, replenishment)
• When item is moved (slotting changes)
• Empty locations (quick verification)

def opportunity_counting_logic(current_activity, location_activity_log):
    """
    Identify opportunistic counting moments

    Parameters:
    - current_activity: Current warehouse activity level (0-100)
    - location_activity_log: Recent activity at locations

    Returns:
    - Recommended locations to count now
    """

    opportunities = []

    # Low activity period
    if current_activity  0 else 0

    # Determine if within tolerance
    within_tolerance = (
        abs(variance_qty)  0 else 0

    # Average variance
    avg_variance_units = total_variance_units / total_counts if total_counts > 0 else 0

    # Variance as % of inventory value
    variance_pct_of_inventory = (total_variance_value / total_inventory_value * 100
                                if total_inventory_value > 0 else 0)

    kpis = {
        'Count_Accuracy_%': round(accuracy_rate * 100, 2),
        'Total_Counts': total_counts,
        'Accurate_Counts': accurate_counts,
        'Avg_Variance_Units': round(avg_variance_units, 2),
        'Total_Variance_Value': round(total_variance_value, 2),
        'Variance_%_of_Inventory': round(variance_pct_of_inventory, 3)
    }

    return kpis

# Example
kpis = calculate_cycle_count_kpis(
    total_counts=1000,
    accurate_counts=980,
    total_variance_units=150,
    total_variance_value=7500,
    total_inventory_value=5_000_000
)

print("Cycle Count KPIs:")
for metric, value in kpis.items():
    print(f"  {metric}: {value}")

Benchmark Targets

| Metric | Target | World-Class | |--------|--------|-------------| | Overall Inventory Accuracy | 98%+ | 99.5%+ | | A Item Accuracy | 99%+ | 99.9%+ | | B Item Accuracy | 97%+ | 99%+ | | C Item Accuracy | 95%+ | 98%+ | | Counts per Day (per 1000 SKUs) | 5-10 | 10-15 | | Time per Count | 3-5 min | 2-3 min | | Recount Rate | 1000: approach = 'Blind count' reason = 'High value or Class A item'

elif previous_accuracy 0 else 0

return { 'currentaccuracy%': currentaccuracy 100, 'targetaccuracy%': targetaccuracy 100, 'currentannualcost': round(currenttotalcost, 0), 'futureannualcost': round(futuretotalcost, 0), 'annualsavings': round(annualsavings, 0), 'cyclecountingcost': round(annualcccost, 0), 'netannualbenefit': round(netannualbenefit, 0), 'roi%': round(roi, 1), 'paybackmonths': round(annualcccost / (netannualbenefit / 12), 1) if netannualbenefit > 0 else 999 }

Example

roi = cyclecountingroi( currentaccuracy=0.90, targetaccuracy=0.98, annualrevenue=50000000, stockoutcostpct=0.02, excessinventorycostpct=0.01 )

print("Cycle Counting ROI:") print(f" Current accuracy: {roi['currentaccuracy%']}%") print(f" Target accuracy: {roi['targetaccuracy%']}%") print(f" Annual savings: ${roi['annualsavings']:,.0f}") print(f" Cycle counting cost: ${roi['cyclecountingcost']:,.0f}") print(f" Net annual benefit: ${roi['netannualbenefit']:,.0f}") print(f" ROI: {roi['roi%']}%") print(f" Payback: {roi['payback_months']} months")

---

## Common Challenges & Solutions

### Challenge: Resistance from Operations

**Problem:**
- "We're too busy to count"
- Seen as non-value-added activity
- Disrupts picking operations

**Solutions:**
- Show cost of inaccuracy (stockouts, expediting)
- Integrate counting into workflows (opportunity counting)
- Count during slow periods
- Dedicated counting staff
- Demonstrate quick wins (improved fill rate)

### Challenge: High Variance Rates

**Problem:**
- Many counts outside tolerance
- Constant recounting
- Lack of confidence in accuracy

**Solutions:**
- Root cause analysis (don't just adjust)
- Focus on prevention, not detection
- Improve processes (scanning, verification)
- Training and accountability
- Audit high-variance SKUs more frequently

### Challenge: Labor Constraints

**Problem:**
- Not enough staff to count regularly
- Competing priorities
- Turnover and training gaps

**Solutions:**
- Optimize count schedule (focus on ABC)
- Use technology (RFID, automation)
- Integrate into existing roles
- Simplified processes
- Outsource to 3PL if applicable

### Challenge: Large SKU Count

**Problem:**
- 10,000+ SKUs overwhelming
- Can't count frequently enough
- Resource intensive

**Solutions:**
- ABC focus (80/20 rule)
- Random sampling for C items
- Process-triggered counts
- Technology (RFID, drones)
- Consider product rationalization

### Challenge: System Issues

**Problem:**
- WMS doesn't support cycle counting well
- Manual process prone to errors
- Lack of reporting

**Solutions:**
- Upgrade or implement WMS
- Use spreadsheets/access databases as interim
- RF scanning integration
- Partner with IT for system improvements
- Consider cloud-based WMS

---

## Output Format

### Cycle Counting Program Design Document

**Executive Summary:**
- Program objectives (target accuracy)
- Recommended approach (ABC, frequency)
- Labor and technology requirements
- Expected ROI

**Program Design:**

| Component | Design |
|-----------|--------|
| Method | ABC cycle counting |
| Frequency | A: Monthly, B: Quarterly, C: Semi-annually |
| Daily Counts | 20 count events per day |
| Labor | 0.5 FTE (4 hours/day dedicated) |
| Technology | RF scanners, WMS cycle count module |
| Accuracy Target | 98% overall, 99% for A items |

**Count Schedule:**

| Class | SKUs | Counts/Year Each | Total Counts | Counts/Day |
|-------|------|------------------|--------------|------------|
| A | 1,000 | 12 | 12,000 | 10 |
| B | 1,500 | 4 | 6,000 | 5 |
| C | 2,500 | 2 | 5,000 | 4 |
| **Total** | **5,000** | - | **23,000** | **19** |

**Performance Metrics:**

| Metric | Target | Measurement Frequency |
|--------|--------|-----------------------|
| Overall Accuracy | 98% | Weekly |
| A Item Accuracy | 99% | Weekly |
| Time per Count | 10%
- Monthly root cause analysis report
- Corrective action plans for top 3 causes
- Quarterly review with operations leadership

**Implementation Timeline:**
- Week 1-2: Physical inventory and data cleanup
- Week 3-4: WMS configuration and testing
- Week 5: Staff training
- Week 6: Pilot with A items
- Week 7-8: Full rollout
- Ongoing: Monthly performance reviews

---

## Questions to Ask

If you need more context:
1. What's the current inventory accuracy level?
2. What's the SKU count and ABC distribution?
3. Is there a WMS in place? RF scanning capability?
4. What's the current cycle counting method (if any)?
5. What's driving the initiative? (accuracy issues, audit requirement, cost reduction)
6. How much labor is available for counting?
7. What's the cost impact of inaccuracy? (stockouts, expediting, excess)
8. Are there specific items or areas with accuracy problems?

---

## Related Skills

- **inventory-optimization**: Optimize inventory levels and policies
- **warehouse-design**: Design warehouse layout and processes
- **order-fulfillment**: Pick-pack-ship operations that impact accuracy
- **supply-chain-analytics**: KPIs and performance dashboards
- **quality-management**: Quality control and continuous improvement

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [kishorkukreja](https://github.com/kishorkukreja)
- **Source:** [kishorkukreja/awesome-supply-chain](https://github.com/kishorkukreja/awesome-supply-chain)
- **License:** MIT

Install and usage instructions live in the source repository linked above.