DEV Community: WebKoding

EU Digital Product Passport in WooCommerce: Implementing ESPR Compliance with Structured Data and QR Codes

WebKoding — Wed, 06 May 2026 19:06:59 +0000

The EU's Ecodesign for Sustainable Products Regulation (ESPR) mandates Digital Product Passports (DPP) for most physical goods sold in Europe starting 2026–2030 (phased by category). If you run a WooCommerce store shipping to EU customers, your products will need machine-readable passports containing lifecycle data, materials, repairability scores, and recycling instructions — all accessible via a physical carrier (QR code, RFID, or datamatrix).

This article walks through how we built a self-hosted WooCommerce plugin to generate DPP-compliant structured data and printable QR codes — no third-party SaaS, no ongoing fees.

What Is a Digital Product Passport?

A DPP is a structured data record attached to a physical product containing:

Product identity: GTIN/EAN, model, manufacturer, batch/serial
Materials & substances: Bill of materials, hazardous substances (SVHC list)
Repairability: Spare parts availability, repair manual links, disassembly score
Environmental footprint: Carbon footprint (kg CO₂e), energy efficiency class
End-of-life: Recycling instructions, collection points, recyclate content %
Compliance documents: CE declaration, REACH compliance, test reports

The data must be accessible via a carrier (QR code printed on product/packaging) pointing to a URL that returns structured data in a machine-readable format (JSON-LD recommended by the EU).

1. The Data Model — WooCommerce Product Meta

We store DPP data as WooCommerce product meta, mapped to the EU DPP data model:

<?php
declare(strict_types=1);

class SP_DPP_Data_Model {

    public const FIELDS = [
        // Identity
        'dpp_gtin'                   => 'sanitize_text_field',
        'dpp_manufacturer_name'      => 'sanitize_text_field',
        'dpp_manufacturer_country'   => 'sanitize_text_field',
        'dpp_batch_number'           => 'sanitize_text_field',

        // Materials
        'dpp_main_material'          => 'sanitize_text_field',
        'dpp_recycled_content_pct'   => 'absint',
        'dpp_hazardous_substances'   => 'sanitize_textarea_field',

        // Repairability
        'dpp_repairability_score'    => 'sanitize_text_field',
        'dpp_spare_parts_url'        => 'esc_url_raw',
        'dpp_repair_manual_url'      => 'esc_url_raw',
        'dpp_warranty_years'         => 'absint',

        // Environmental
        'dpp_carbon_footprint_kg'    => 'sanitize_text_field',
        'dpp_energy_class'           => 'sanitize_text_field',
        'dpp_energy_kwh_year'        => 'sanitize_text_field',

        // End of life
        'dpp_recycling_instructions' => 'sanitize_textarea_field',
        'dpp_disassembly_time_min'   => 'absint',
        'dpp_collection_point_url'   => 'esc_url_raw',

        // Compliance
        'dpp_ce_declaration_url'     => 'esc_url_raw',
        'dpp_reach_compliant'        => 'absint',
    ];

    public function save_product_meta( int $product_id ): void {
        if ( ! current_user_can( 'edit_product', $product_id ) ) return;

        if ( ! isset( $_POST['sp_dpp_nonce'] ) || ! wp_verify_nonce(
            sanitize_text_field( wp_unslash( $_POST['sp_dpp_nonce'] ) ),
            'sp_dpp_save_' . $product_id
        ) ) return;

        $product = wc_get_product( $product_id );
        if ( ! $product ) return;

        foreach ( self::FIELDS as $field => $sanitizer ) {
            if ( isset( $_POST[ $field ] ) ) {
                $value = call_user_func( $sanitizer, wp_unslash( $_POST[ $field ] ) );
                $product->update_meta_data( '_' . $field, $value );
            }
        }
        $product->save();
    }

    public function get_passport_data( int $product_id ): array {
        $product = wc_get_product( $product_id );
        if ( ! $product ) return [];

        $data = [];
        foreach ( array_keys( self::FIELDS ) as $field ) {
            $data[ $field ] = $product->get_meta( '_' . $field );
        }
        return $data;
    }
}

2. JSON-LD Passport Endpoint (WP REST API)

The QR code points to a public REST endpoint returning JSON-LD:

<?php
declare(strict_types=1);

class SP_DPP_REST_Controller extends WP_REST_Controller {

    protected $namespace = 'sp-dpp/v1';
    protected $rest_base = 'passport';

    public function register_routes(): void {
        register_rest_route( $this->namespace, '/' . $this->rest_base . '/(?P<product_id>[\d]+)', [
            [
                'methods'             => WP_REST_Server::READABLE,
                'callback'            => [ $this, 'get_passport' ],
                'permission_callback' => '__return_true',  // Public
                'args'                => [
                    'product_id' => [
                        'validate_callback' => fn($v) => is_numeric($v),
                        'sanitize_callback' => 'absint',
                    ],
                ],
            ],
        ] );
    }

    public function get_passport( WP_REST_Request $request ): WP_REST_Response {
        $product_id = $request->get_param( 'product_id' );
        $product    = wc_get_product( $product_id );

        if ( ! $product || ! $product->is_visible() ) {
            return new WP_REST_Response( [ 'error' => 'Product not found' ], 404 );
        }

        $model = new SP_DPP_Data_Model();
        $data  = $model->get_passport_data( $product_id );

        $passport = [
            '@context' => [
                'schema' => 'https://schema.org/',
                'dpp'    => 'https://digital-product-passport.eu/ns#',
            ],
            '@type'       => [ 'schema:Product', 'dpp:DigitalProductPassport' ],
            '@id'         => get_permalink( $product_id ),
            'schema:name' => $product->get_name(),
            'schema:gtin' => $data['dpp_gtin'],
            'dpp:materials' => [
                'dpp:primaryMaterial'    => $data['dpp_main_material'],
                'dpp:recycledContentPct' => (int) $data['dpp_recycled_content_pct'],
                'dpp:hazardousSubstances' => json_decode( $data['dpp_hazardous_substances'] ?: '[]', true ),
            ],
            'dpp:repairability' => [
                'dpp:score'         => $data['dpp_repairability_score'],
                'dpp:sparePartsUrl' => $data['dpp_spare_parts_url'],
                'dpp:repairManual'  => $data['dpp_repair_manual_url'],
                'dpp:warrantyYears' => (int) $data['dpp_warranty_years'],
            ],
            'dpp:environmental' => [
                'dpp:carbonFootprintKg' => (float) $data['dpp_carbon_footprint_kg'],
                'dpp:energyClass'       => $data['dpp_energy_class'],
                'dpp:energyKwhYear'     => (float) $data['dpp_energy_kwh_year'],
            ],
            'dpp:endOfLife' => [
                'dpp:recyclingInstructions' => $data['dpp_recycling_instructions'],
                'dpp:disassemblyTimeMin'    => (int) $data['dpp_disassembly_time_min'],
                'dpp:collectionPointUrl'    => $data['dpp_collection_point_url'],
            ],
            'dpp:compliance' => [
                'dpp:ceDeclarationUrl' => $data['dpp_ce_declaration_url'],
                'dpp:reachCompliant'   => (bool) $data['dpp_reach_compliant'],
            ],
            'dpp:generatedAt' => gmdate( 'c' ),
        ];

        $response = new WP_REST_Response( $passport, 200 );
        $response->header( 'Content-Type', 'application/ld+json' );
        $response->header( 'Cache-Control', 'public, max-age=3600' );
        return $response;
    }
}

Endpoint URL: https://yourstore.com/wp-json/sp-dpp/v1/passport/123

3. QR Code Generation (No External API)

<?php
declare(strict_types=1);

class SP_DPP_QR_Generator {

    public function generate_qr( int $product_id, int $size = 300 ): string {
        $passport_url = rest_url( 'sp-dpp/v1/passport/' . $product_id );

        $cache_key = 'sp_dpp_qr_' . $product_id . '_' . $size;
        $cached    = get_transient( $cache_key );
        if ( $cached ) return $cached;

        require_once SP_DPP_PATH . 'vendor/phpqrcode/qrlib.php';

        ob_start();
        QRcode::png( $passport_url, false, QR_ECLEVEL_M, 10, 2 );
        $raw_png = ob_get_clean();

        $data_uri = 'data:image/png;base64,' . base64_encode( $raw_png );
        set_transient( $cache_key, $data_uri, WEEK_IN_SECONDS );

        return $data_uri;
    }

    public function save_qr_file( int $product_id ): string {
        $upload_dir = wp_upload_dir();
        $dpp_dir    = trailingslashit( $upload_dir['basedir'] ) . 'sp-dpp-qr/';

        if ( ! file_exists( $dpp_dir ) ) {
            wp_mkdir_p( $dpp_dir );
            file_put_contents( $dpp_dir . 'index.php', '<?php // Silence is golden.' );
        }

        $filename = 'dpp-qr-' . $product_id . '.png';
        require_once SP_DPP_PATH . 'vendor/phpqrcode/qrlib.php';
        QRcode::png( rest_url( 'sp-dpp/v1/passport/' . $product_id ), $dpp_dir . $filename, QR_ECLEVEL_M, 10, 2 );

        return trailingslashit( $upload_dir['baseurl'] ) . 'sp-dpp-qr/' . $filename;
    }
}

4. Admin Product Tab

<?php
add_filter( 'woocommerce_product_data_tabs', function( array $tabs ): array {
    $tabs['sp_dpp'] = [
        'label'    => __( 'Digital Passport', 'sp-dpp' ),
        'target'   => 'sp_dpp_product_data',
        'priority' => 85,
    ];
    return $tabs;
} );

add_action( 'woocommerce_product_data_panels', function(): void {
    global $post;
    wp_nonce_field( 'sp_dpp_save_' . $post->ID, 'sp_dpp_nonce' );
    echo '<div id="sp_dpp_product_data" class="panel woocommerce_options_panel">';

    echo '<div class="options_group">';
    woocommerce_wp_text_input([
        'id'          => 'dpp_gtin',
        'label'       => __( 'GTIN / EAN', 'sp-dpp' ),
        'description' => __( 'Global Trade Item Number', 'sp-dpp' ),
        'desc_tip'    => true,
        'value'       => get_post_meta( $post->ID, '_dpp_gtin', true ),
    ]);
    woocommerce_wp_text_input([
        'id'    => 'dpp_repairability_score',
        'label' => __( 'Repairability Score (e.g. 7.5/10)', 'sp-dpp' ),
        'value' => get_post_meta( $post->ID, '_dpp_repairability_score', true ),
    ]);
    woocommerce_wp_text_input([
        'id'    => 'dpp_carbon_footprint_kg',
        'label' => __( 'Carbon Footprint (kg CO₂e)', 'sp-dpp' ),
        'value' => get_post_meta( $post->ID, '_dpp_carbon_footprint_kg', true ),
    ]);
    echo '</div>';

    // QR preview
    $qr  = new SP_DPP_QR_Generator();
    $src = $qr->generate_qr( $post->ID, 200 );
    echo '<div class="options_group">';
    echo '<p><strong>' . esc_html__( 'DPP QR Code', 'sp-dpp' ) . '</strong></p>';
    echo '<img src="' . esc_attr( $src ) . '" width="150" />';
    echo '<p><a href="' . esc_url( rest_url( 'sp-dpp/v1/passport/' . $post->ID ) ) . '" target="_blank">'
        . esc_html__( 'View Passport JSON-LD', 'sp-dpp' ) . '</a></p>';
    echo '</div>';
    echo '</div>';
} );

5. Bulk Import via WooCommerce CSV

<?php
add_filter( 'woocommerce_csv_product_import_mapping_default_columns', function( array $columns ): array {
    return array_merge( $columns, [
        'GTIN'                => 'dpp_gtin',
        'Manufacturer'        => 'dpp_manufacturer_name',
        'Carbon Footprint kg' => 'dpp_carbon_footprint_kg',
        'Recycled Content %'  => 'dpp_recycled_content_pct',
        'Repairability Score' => 'dpp_repairability_score',
        'Energy Class'        => 'dpp_energy_class',
    ] );
} );

add_filter( 'woocommerce_product_import_pre_insert_product_object',
function( WC_Product $product, array $data ): WC_Product {
    foreach ( array_keys( SP_DPP_Data_Model::FIELDS ) as $field ) {
        if ( isset( $data[ $field ] ) ) {
            $product->update_meta_data( '_' . $field, sanitize_text_field( $data[ $field ] ) );
        }
    }
    return $product;
}, 10, 2 );

ESPR Rollout Timeline

Year	Categories
2026	Batteries, textiles, electronics
2027	Furniture, steel, cement, chemicals
2028–2030	All remaining categories

The DPP endpoint must stay accessible for the full product lifecycle — typically 10+ years after sale.

Why Self-Hosted?

DPP SaaS platforms (Circularise, Renoon, Fairly Made) charge €200–500/mo per brand. For most WooCommerce stores, a one-time plugin generating compliant JSON-LD and QR codes covers the full technical requirement without ongoing costs.

The full plugin is on CodeCanyon: EU Digital Product Passport for WooCommerce (ESPR)

Questions about the JSON-LD structure or ESPR data requirements? Drop them in the comments.

Implementing ZATCA Phase 2 E-Invoicing in WooCommerce: UBL XML, XAdES Signing, and Hash Chains

WebKoding — Wed, 06 May 2026 18:51:21 +0000

Saudi Arabia's ZATCA Phase 2 e-invoicing mandate is one of the most technically demanding compliance requirements I've encountered in WooCommerce development. It's not just generating a PDF — it's UBL 2.1 XML, XAdES-BES digital signatures, a cryptographic hash chain, TLV-encoded QR codes, and real-time API submission to government servers.

Here's how I built FatooraPro, a WooCommerce plugin that handles the full ZATCA Phase 2 flow.

What ZATCA Phase 2 Actually Requires

Every invoice must:

Be generated as UBL 2.1 compliant XML
Be digitally signed with XAdES-BES using a ZATCA-issued certificate
Include a TLV-encoded QR code with 8 specific fields
Maintain a hash chain (each invoice's hash references the previous one)
Be submitted to ZATCA's API — either for clearance (B2B) before delivery, or reporting (B2C) within 24 hours

Miss any of these and the invoice is legally invalid.

The Two Invoice Types

Standard Tax Invoice (B2B — Clearance)
Submitted to ZATCA before the invoice is delivered to the buyer. ZATCA must approve it. This means your checkout flow has to wait for an API response, or queue it and hold the invoice.

Simplified Tax Invoice (B2C — Reporting)
Submitted to ZATCA within 24 hours. More lenient — you can generate and deliver the invoice immediately, then report asynchronously.

In WooCommerce, I detect the invoice type based on whether the buyer has a VAT number (B2B) or not (B2C).

UBL 2.1 XML Structure

ZATCA requires a specific XML namespace and field order. Here's a simplified version of what the XML looks like:

<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
         xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
         xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2">
  <cbc:ProfileID>reporting:1.0</cbc:ProfileID>
  <cbc:ID>INV-2026-001</cbc:ID>
  <cbc:UUID>6f4d3885-0e99-4f13-9c8b-...</cbc:UUID>
  <cbc:IssueDate>2026-05-06</cbc:IssueDate>
  <cbc:IssueTime>14:30:00</cbc:IssueTime>
  <cbc:InvoiceTypeCode name="0200000">388</cbc:InvoiceTypeCode>
  <!-- Seller info, buyer info, line items, tax totals... -->
</Invoice>

The InvoiceTypeCode name attribute is a 7-digit bitmask that encodes invoice properties (standard/simplified, credit/debit, etc.).

XAdES-BES Digital Signing

This is where it gets complex. ZATCA requires XAdES-BES (XML Advanced Electronic Signatures, Basic Electronic Signature profile). In PHP:

function sign_invoice( string $xml, string $private_key_pem, string $certificate_pem ): string {
    // 1. Canonicalize the XML (C14N)
    $dom = new DOMDocument();
    $dom->loadXML( $xml );
    $canonical = $dom->C14N( false, false );

    // 2. Hash the canonicalized XML
    $digest = base64_encode( hash( 'sha256', $canonical, true ) );

    // 3. Build SignedInfo element with digest
    $signed_info = $this->build_signed_info( $digest );

    // 4. Sign the SignedInfo with the private key
    openssl_sign( $signed_info, $signature_raw, $private_key_pem, OPENSSL_ALGO_SHA256 );
    $signature_value = base64_encode( $signature_raw );

    // 5. Embed certificate hash and signature into XML
    return $this->embed_signature( $xml, $signature_value, $certificate_pem, $digest );
}

The certificate itself is issued by ZATCA through a 4-step onboarding process: CSR generation → Compliance CSID → Simulation testing → Production CSID.

The Hash Chain (PIH/ICV)

ZATCA requires sequential invoice integrity. Each invoice must contain:

ICV (Invoice Counter Value): sequential integer starting at 1
PIH (Previous Invoice Hash): SHA-256 hash of the previous invoice's XML

This means invoices are cryptographically linked — you can't insert, delete, or modify an old invoice without breaking the chain. In WooCommerce, I store the last hash in a WordPress option and update it atomically after each successful submission:

function get_and_increment_icv(): array {
    // Use DB transaction to prevent race conditions
    global $wpdb;
    $wpdb->query( 'START TRANSACTION' );

    $current_icv  = (int) get_option( 'fatoorapro_icv', 0 );
    $previous_hash = get_option( 'fatoorapro_pih', hash( 'sha256', 'NWZlY2ViNjZmZmM4NmYzOGQ5NTI3ODZjNmQ2OTZjNzljMmRiYzIzOWRkNGU5MWI0NjcyOWQ3M2EyN2YzNDkyMQ==' ) );

    $new_icv = $current_icv + 1;
    update_option( 'fatoorapro_icv', $new_icv );

    $wpdb->query( 'COMMIT' );

    return [ 'icv' => $new_icv, 'pih' => $previous_hash ];
}

The default PIH for the first invoice is a SHA-256 hash of a specific base64 string defined in ZATCA's spec.

TLV-Encoded QR Code

ZATCA's QR code uses Tag-Length-Value encoding, not a simple URL. It must contain 8 fields:

function generate_tlv_qr( array $data ): string {
    $tlv = '';
    $fields = [
        1 => $data['seller_name'],           // Seller name
        2 => $data['vat_number'],            // VAT registration number  
        3 => $data['timestamp'],             // Invoice timestamp
        4 => $data['total_with_vat'],        // Invoice total with VAT
        5 => $data['vat_amount'],            // VAT amount
        6 => $data['xml_hash'],              // Invoice XML hash (B2B only)
        7 => $data['ecdsa_signature'],       // ECDSA signature (B2B only)
        8 => $data['public_key'],            // Public key (B2B only)
    ];

    foreach ( $fields as $tag => $value ) {
        $encoded = mb_convert_encoding( $value, 'UTF-8' );
        $length  = strlen( $encoded );
        $tlv    .= chr( $tag ) . chr( $length ) . $encoded;
    }

    return base64_encode( $tlv );
}

Async Submission with WP-Cron

B2B clearance requires synchronous submission (blocking). But B2C reporting can be async. I use WP-Cron for retry logic on failures:

function schedule_submission( int $invoice_id ): void {
    wp_schedule_single_event(
        time() + 30, // 30 second delay
        'fatoorapro_submit_invoice',
        [ $invoice_id ]
    );
}

add_action( 'fatoorapro_submit_invoice', function( int $invoice_id ): void {
    $result = submit_to_zatca( $invoice_id );

    if ( ! $result['success'] ) {
        $attempts = (int) get_post_meta( $invoice_id, '_zatca_attempts', true );
        if ( $attempts < 3 ) {
            update_post_meta( $invoice_id, '_zatca_attempts', $attempts + 1 );
            wp_schedule_single_event( time() + 300, 'fatoorapro_submit_invoice', [ $invoice_id ] ); // retry in 5 min
        }
    }
} );

HPOS Compatibility

ZATCA data is stored per-order, so it needs to work with both classic order posts and HPOS. I use WooCommerce's order meta abstraction:

// Works with both post meta and HPOS order tables
$order->update_meta_data( '_zatca_status', 'cleared' );
$order->update_meta_data( '_zatca_uuid', $uuid );
$order->update_meta_data( '_zatca_qr', $qr_code );
$order->save();

The Onboarding Flow

Getting a production certificate from ZATCA requires 4 steps:

CSR generation — create a private key + certificate signing request with your VAT number embedded
Compliance CSID — submit CSR to ZATCA, get a compliance certificate back
Compliance tests — run 6 predefined test invoices against ZATCA's sandbox
Production CSID — exchange compliance certificate for production certificate

I built a 4-step wizard in WP Admin that walks store owners through this. Most of them aren't developers, so the UI has to handle the complexity invisibly.

I packaged all of this into FatooraPro — a complete ZATCA Phase 2 solution for WooCommerce stores in Saudi Arabia: FatooraPro on CodeCanyon

Happy to go deeper on any part — the XAdES signing and hash chain were the most challenging pieces.

WooCommerce Only Allows One Tax Rate Per Line Item — Here's How I Solved It

WebKoding — Wed, 06 May 2026 18:30:54 +0000

WooCommerce has a limitation that quietly causes legal compliance issues for thousands of stores across Germany, Austria, France, and other EU countries: you can only assign one tax class per line item.

For most stores this is fine. But if you sell brunch tickets, hotel packages, event passes, or any product that legally requires multiple VAT rates on a single invoice — you have a problem.

The Real-World Problem

Take a brunch ticket priced at €39. In Germany, food is taxed at 7% and beverages at 19%. Since January 1, 2026, the German BMF (Bundesministerium der Finanzen) requires that invoices for such products show the split explicitly:

Item	Net	VAT	Gross
Food portion (80%)	€29.16	7% → €2.04	€31.20
Drinks portion (20%)	€6.55	19% → €1.24	€7.80
Total	€35.71	€3.28	€39.00

Without the split, your invoice is legally non-compliant — the customer overpays VAT by €2.94, and your tax report is wrong. Similar requirements exist in Austria, Switzerland, and France.

Why WooCommerce Can't Do This Natively

WooCommerce's order data model stores tax per line item as a single tax class. There is no native concept of sub-items within a line item — you can't attach two different tax rates to one product without fundamentally changing how the order is stored.

The Approach: Virtual Split Parts in Order Meta

The solution is to store split rules on the product, then at order creation inject virtual line items into order metadata — one per split part — while keeping the customer-facing display as a single product.

Step 1: Product-Level Split Rules

// Stored as product meta: _splitvat_rules
$rules = [
    [
        'label'      => 'Food portion',
        'percentage' => 80,
        'tax_class'  => 'reduced-rate', // 7% in Germany
    ],
    [
        'label'      => 'Drinks portion',
        'percentage' => 20,
        'tax_class'  => 'standard',     // 19% in Germany
    ],
];

Step 2: Hooking Into Order Creation

add_action(
    'woocommerce_checkout_create_order_line_item',
    function( $item, $cart_item_key, $values, $order ) {
        $product = $item->get_product();
        $rules   = get_post_meta( $product->get_id(), '_splitvat_rules', true );

        if ( empty( $rules ) ) {
            return;
        }

        $split_parts = splitvat_calculate_parts( $item->get_total(), $rules );
        $item->add_meta_data( '_splitvat_parts', $split_parts, true );
        $item->add_meta_data( '_splitvat_enabled', true, true );
    },
    10, 4
);

Step 3: Penny-Perfect Rounding

Splitting €39 into 80/20 is clean, but many totals produce floating point rounding errors. The "remainder on last" algorithm fixes this:

function splitvat_calculate_parts( float $total, array $rules ): array {
    $parts      = [];
    $allocated  = 0.0;
    $last_index = count( $rules ) - 1;

    foreach ( $rules as $index => $rule ) {
        if ( $index === $last_index ) {
            $amount = round( $total - $allocated, 2 ); // remainder — no drift
        } else {
            $amount    = round( $total * ( $rule['percentage'] / 100 ), 2 );
            $allocated += $amount;
        }
        $parts[] = array_merge( $rule, [ 'amount' => $amount ] );
    }

    return $parts;
}

This guarantees split parts always sum to exactly the original total.

Step 4: HPOS Compatibility

If you're on WooCommerce High-Performance Order Storage, always use the order abstraction layer — not direct SQL:

// Always use this
$orders = wc_get_orders([
    'status'     => ['completed', 'processing'],
    'meta_query' => [[
        'key'   => '_splitvat_enabled',
        'value' => true,
    ]]
]);

Accounting Export Formats

Different countries need different export formats:

DATEV Buchungsstapel — Germany (direct import into tax advisor software)
BMD/RZL — Austria (Steuercode + Kontenrahmen mapping)
FEC — France (18 mandatory fields, required by tax authorities)
CSV — Universal (Excel, Google Sheets, any tool)

The Key Insight

Orders are immutable records. Do the heavy lifting at checkout, store the computed split in order item meta, and read it back whenever you need it (invoices, exports, reports). Trying to recalculate after the fact is unreliable — prices and tax rates can change.

I packaged all of this into SplitVAT — 13 country presets, 4 export formats, and integrations for the major WooCommerce invoice plugins. If you're dealing with this compliance problem: SplitVAT on CodeCanyon

Happy to go deeper on any part of the implementation.

Dead Stock is Silently Killing Your WooCommerce Store (And How to Find It)

WebKoding — Wed, 25 Mar 2026 07:20:33 +0000

Most WooCommerce store owners focus on what's selling. But the real profit killer is what isn't selling — dead stock.

What is dead stock?

Dead stock is inventory that hasn't sold in 60+ days and has more than a few weeks of stock remaining. It's capital sitting in your warehouse doing nothing — and often getting worse:

Storage costs keep accumulating
Products may expire, go out of fashion, or become obsolete
Cash that could fund better-selling products is locked up
Eventually it becomes a write-off

The detection formula

In StockPulse, I flag a product as dead stock when:

current_stock > minimum_threshold
AND
units_sold_last_60_days = 0
AND
days_of_stock_remaining > 60

Simple, but surprisingly revealing when you run it across your full catalog.

What to do with dead stock

1. Bundle it — pair slow movers with bestsellers. A customer buying a $50 product might add a $10 dead-stock item for $5.

2. Run a clearance sale — even 20-30% margin recovery is better than a full write-off.

3. Return to supplier — if your agreement allows it, especially for newer inventory.

4. Liquidate wholesale — sell in bulk at cost to clear warehouse space.

5. Donate for tax benefit — in some countries, donated inventory generates a tax deduction.

Prevention with reorder discipline

The best cure is prevention. StockPulse's reorder point system means you only reorder what you're actually selling, and in quantities aligned with your real velocity — not gut feeling or "round numbers."

If your daily velocity on a product is 0.3 units/day and your lead time is 14 days, you need a reorder point of about 6 units — not the 50 you ordered "just in case."

See your dead stock in real time

The StockPulse Reports page shows all dead stock products at a glance, sorted by estimated capital tied up. It's often the first time store owners see the full picture — and the numbers are usually surprising.

Try the live demo at https://stockpulse.webkodingtheme.com or grab it on CodeCanyon: https://codecanyon.net/item/stockpulse-inventory-forecast-sales-intelligence-for-woocommerce/62458013

How I Implemented Inventory Forecasting Algorithms in a WordPress Plugin

WebKoding — Wed, 25 Mar 2026 07:17:52 +0000

When building StockPulse, the core challenge was: how do you calculate reliable inventory forecasts when different products have wildly different sales patterns?

Here's a breakdown of the forecasting engine I built.

Three velocity algorithms, automatic selection

The SP_Velocity_Calculator class implements three approaches:

Simple Moving Average (SMA) — baseline, used when less than 90 days of data exists:

$velocity = array_sum($daily_sales) / count($daily_sales);

Weighted Moving Average (WMA) — recent days get higher weight:

$total_weight = ($n * ($n + 1)) / 2;
$weighted_sum = 0;
foreach ($daily_sales as $i => $sales) {
    $weight = $i + 1;
    $weighted_sum += $sales * $weight;
}
$velocity = $weighted_sum / $total_weight;

Exponential Smoothing — alpha=0.3 by default (configurable per product):

$smoothed = $daily_sales[0];
foreach (array_slice($daily_sales, 1) as $actual) {
    $smoothed = ($alpha * $actual) + ((1 - $alpha) * $smoothed);
}
$velocity = $smoothed;

The engine auto-selects: less than 90 days of history → SMA, 90+ days → WMA.

Reorder point formula

public function calculate_reorder_point(
    float $daily_velocity,
    int $lead_time_days
): float {
    $safety_stock = $daily_velocity * ($lead_time_days * 0.25);
    return ($daily_velocity * $lead_time_days) + $safety_stock;
}

The 25% safety buffer accounts for supplier delays and demand spikes.

Seasonal adjustment

$seasonal_coefficient = $same_period_last_year / $last_month_average;
$adjusted_velocity = $base_velocity * $seasonal_coefficient;

This naturally handles Christmas spikes, summer slowdowns, etc.

HPOS compatibility

WooCommerce's High-Performance Order Storage moved orders to custom tables. Instead of querying wp_posts directly:

$orders = wc_get_orders([
    'status'     => ['wc-completed'],
    'date_after' => date('Y-m-d', strtotime('-90 days')),
    'return'     => 'ids',
    'limit'      => -1,
]);

Caching architecture

All calculations are stored in wp_stockpulse_product_cache with a 24-hour TTL, refreshed daily via WP-Cron.

What's next

v1.1 will add purchase order PDF generator and ABC analysis.

I Built a WooCommerce Inventory Forecasting Plugin — Self-Hosted, No Monthly Fees

WebKoding — Wed, 25 Mar 2026 07:13:29 +0000

After months of development, I just launched StockPulse — a WooCommerce plugin that turns your order history into an inventory intelligence system.

The problem I was solving

Running a WooCommerce store means constantly answering questions like:

"How many days of stock do I have left for each product?"
"When should I reorder before I run out?"
"Which products have been sitting in my warehouse for 60+ days with zero sales?"

The existing solutions are either expensive SaaS tools ($49–199/month) or ancient CodeCanyon plugins that haven't been updated since 2017. I wanted something self-hosted, one-time payment, no external API calls.

What StockPulse does

Days of Stock Remaining — calculates how many days your current stock will last based on your actual sales velocity.

Smart Reorder Points — tells you exactly when to reorder, factoring in your supplier lead time plus a 25% safety buffer:

reorder_point = (daily_velocity × lead_time_days) + safety_stock
safety_stock = daily_velocity × (lead_time_days × 0.25)

Dead Stock Detection — flags products with 60+ days of stock and zero recent sales so you can run promotions before they become a write-off.

30/60/90-day demand forecasts — projects future demand using three algorithms (SMA, WMA, Exponential Smoothing) with automatic selection based on data availability.

Email alerts — notifies you when products hit critical stock levels.

CSV export — full data export for deeper analysis.

The tech stack

Built with PHP 7.4+ (OOP, PSR-4 structure), vanilla JS + Chart.js for the admin dashboard, WordPress REST API for data endpoints, and WP-Cron for daily cache refresh.

Fully HPOS-compatible (uses wc_get_orders() — no raw SQL on order tables).

Why self-hosted matters

All calculations happen on your server
No data leaves your store
GDPR compliant by design
No API key to manage, no service to go down

Live demo + CodeCanyon

Demo: https://stockpulse.webkodingtheme.com
CodeCanyon: https://codecanyon.net/item/stockpulse-inventory-forecast-sales-intelligence-for-woocommerce/62458013

Would love feedback from the WooCommerce/WordPress dev community. What features would you want to see in v1.1?