Document Title: ISO 22468:2020 VSM Go SDK Developer Guide
Document Version: 1.0
Document Date: December 2025
Software Version: v1.0.0
Compliance Standard: ISO/IEC/IEEE 26514:2017

• Total Sections: 10 main sections
• Total Subsections: 14 subsections
• Code Examples: 25+ practical examples
• Compliance: ISO/IEC/IEEE 26514:2017

This document provides comprehensive guidance for developers implementing Value Stream Management (VSM) solutions using the ISO 22468:2020 VSM Go SDK. The SDK offers a complete Go implementation of the ISO 22468:2020 standard, enabling systematic analysis, design, planning, and assessment of value streams in manufacturing and service processes.

The primary purposes of this SDK are to:

• Provide standardized VSM implementation compliant with ISO 22468:2020
• Enable automated calculation of key performance indicators (KPIs)
• Support complete VSM workflow from current state analysis to future state implementation
• Facilitate waste identification and reduction opportunities

This documentation covers:

• Installation and setup of the VSM Go SDK
• Core concepts and architecture of the SDK
• Step-by-step procedures for VSM implementation
• API reference for all SDK components
• Calculation procedures and formulas from ISO 22468:2020 Annex A
• Troubleshooting common issues and error conditions

This documentation does not cover:

• General Go programming language concepts
• ISO 22468:2020 standard interpretation (refer to the standard itself)
• Lean manufacturing principles beyond VSM scope
• Third-party Go libraries used by the SDK

This guide is intended for:

• Software Developers: Go developers implementing VSM solutions
• Process Engineers: Engineers requiring automated VSM analysis tools
• System Architects: Architects designing manufacturing execution systems
• Quality Assurance Specialists: QA professionals validating VSM implementations

Assumed Knowledge:

• Basic proficiency in Go programming language
• Understanding of manufacturing processes and value streams
• Familiarity with lean manufacturing concepts
• Knowledge of JSON data structures

Before using this SDK, ensure you have:

Software Requirements:

• Go 1.19 or later
• Operating system: Windows, macOS, or Linux

Knowledge Prerequisites:

• Go programming fundamentals (variables, functions, structs, interfaces)
• Basic understanding of JSON serialization
• Familiarity with manufacturing process terminology
• Understanding of value stream mapping concepts

Value Stream Management (VSM) is a lean methodology for analyzing and improving the flow of materials and information required to bring a product or service to a customer. The methodology focuses on identifying and eliminating waste while optimizing value-adding activities.

The VSM process consists of four main phases:

1. Analysis Phase: Mapping the current state and identifying bottlenecks and waste
2. Design Phase: Creating future state designs with improvement opportunities
3. Planning Phase: Developing implementation plans with specific measures
4. Assessment Phase: Monitoring performance and managing continuous improvement

The SDK implements the complete VSM methodology through four main components:

• Analyzer: Performs current state analysis including bottleneck detection and waste analysis
• Designer: Creates future state designs and identifies improvement potentials
• Planner: Develops implementation plans with SMART (Specific, Measurable, Achievable, Relevant, Time-bound) measures
• Assessor: Monitors performance against targets and manages PDCA (Plan-Do-Check-Act) cycles

The central data structure representing a complete value stream with:

• Processes (material, energy, data transformations)
• Inventory points and buffers
• Customer and supplier interfaces
• Flow controls and information flows

All parameters defined in ISO 22468:2020 Annex A:

• Process Time (PT) = Processing Time + Setup Time + Handling Time + Waiting Time + Administrative Time
• Cycle Time (CT): Time between process completions
• Lead Time (LT) = Value-Added Time + Non-Value-Added Time + Necessary Non-Value-Added Time
• Yield Factor (YF) = 1 - (Scrap Rate + Rework Rate)

Automated calculation of key performance indicators:

• Value-Added Ratio = VAT / LT
• Process Efficiency = VAT / PT
• Customer Takt Time = Operating Time / Customer Demand
• Inventory Turns = Customer Demand / Stock Quantity

To install the VSM Go SDK in your Go project:

1. Ensure you have Go 1.19 or later installed
2. Open a terminal in your project directory
3. Run the following command:

go get github.com/iso22468/vsm-go-sdk

4. Import the package in your Go code:

import vsm "github.com/iso22468/vsm-go-sdk"

Expected Result: The SDK is now available in your Go module dependencies.

Follow these steps to create your first VSM analysis:

package main

import (
    "fmt"
    "log"
    vsm "github.com/iso22468/vsm-go-sdk"
)

func main() {
    // Define customer requirements
    customer := &vsm.Customer{
        ID:       "customer_1",
        Name:     "Manufacturing Corp",
        Demand:   1000, // units per period
        TaktTime: 5.0,  // time units per unit
    }

    // Create value stream
    vs := &vsm.ValueStream{
        ID:            "production_line_1",
        Name:          "Main Production Line",
        State:         vsm.StateCurrent,
        ProductFamily: "Widget Family A",
        Customer:      customer,
    }

    fmt.Printf("Created value stream: %s\n", vs.Name)
}

// Add manufacturing processes
processes := []vsm.Process{
    {
        ID:   "receiving",
        Name: "Receiving",
        Type: vsm.ProcessTypeMaterial,
        Parameters: vsm.ProcessParameters{
            ProcessTime:    30,   // minutes
            CycleTime:      5,    // minutes
            YieldFactor:    0.98, // 98% yield
            TimeUnit:       vsm.TimeUnitMinutes,
            SetupTime:      10,
            WaitingTime:    15,
        },
    },
    {
        ID:   "assembly",
                Name: "Assembly",
                Type: vsm.ProcessTypeMaterial,
                Parameters: vsm.ProcessParameters{
            ProcessTime:    45,
            CycleTime:      8,
            YieldFactor:    0.95,
            TimeUnit:       vsm.TimeUnitMinutes,
            SetupTime:      20,
            WaitingTime:    10,
        },
    },
}

vs.Processes = processes

// Create analyzer and analyze current state
analyzer := vsm.NewAnalyzer()
analysis, err := analyzer.AnalyzeCurrentState(vs)
if err != nil {
    log.Fatalf("Analysis failed: %v", err)
}

// Display results
fmt.Printf("Bottlenecks found: %d\n", len(analysis.Bottlenecks))
fmt.Printf("Waste reduction potential: %.1f%%\n",
    analysis.WasteAnalysis.WasteReductionPotential)

calculator := vsm.NewCalculator()
kpis, err := calculator.CalculateKPIs(vs)
if err != nil {
    log.Fatalf("KPI calculation failed: %v", err)
}

fmt.Printf("Value-added ratio: %.2f%%\n", kpis["value_added_ratio"]*100)
fmt.Printf("Process efficiency: %.2f%%\n", kpis["process_efficiency"]*100)

inventory := []vsm.Inventory{
    {
        ID:          "raw_materials",
        Name:        "Raw Materials Buffer",
        Type:        vsm.InventoryTypeWIP,
        Quantity:    500,
        TurnRate:    12, // turns per year
        HoldingCost: 0.15, // 15% of value per year
    },
}

vs.Inventory = inventory

// Analyze current state first
    analysis, _ := analyzer.AnalyzeCurrentState(vs)

// Create designer and design future state
designer := vsm.NewDesigner()
project := &vsm.Project{
    ID:          "improvement_project_1",
    Name:        "Lean Transformation Initiative",
    Objectives:  []string{"Reduce lead time by 30%", "Increase efficiency by 25%"},
    Timeframe:   "6 months",
    Budget:      50000.0,
}

design, err := designer.DesignFutureState(analysis, project)
if err != nil {
    log.Fatalf("Future state design failed: %v", err)
}

fmt.Printf("Identified %d improvement potentials\n", len(design.ImprovementPotentials))

planner := vsm.NewPlanner()
plan, err := planner.PlanImplementation(design, project)
if err != nil {
    log.Fatalf("Planning failed: %v", err)
}

fmt.Printf("Generated %d SMART measures\n", len(plan.CatalogueOfMeasures.Measures))
fmt.Printf("Workshop scheduled for: %s\n", plan.WorkshopPlan.Date)

assessor := vsm.NewAssessor()

// Define performance targets
targets := map[string]float64{
    "value_added_ratio":    0.30, // 30%
    "process_efficiency":   0.60, // 60%
    "on_time_delivery":     0.95, // 95%
}

// Historical performance data
history := []vsm.PerformanceData{
    {
        Timestamp: time.Now().AddDate(0, -1, 0), // 1 month ago
        KPIs: map[string]float64{
            "value_added_ratio": 0.22,
            "process_efficiency": 0.45,
        },
    },
}

assessment, err := assessor.AssessValueStream(vs, targets, history)
if err != nil {
    log.Fatalf("Assessment failed: %v", err)
}

fmt.Printf("Performance index: %.2f/100\n", assessment.PerformanceIndex*100)
for _, action := range assessment.ActionItems {
    fmt.Printf("Recommended action: %s\n", action.Description)
}

The main data structure representing a complete value stream.

type ValueStream struct {
    ID            string       // Unique identifier
    Name          string       // Display name
    State         State        // Current, Future, or Ideal
    ProductFamily string       // Product family name
    Customer      *Customer    // Customer requirements
    Supplier      *Supplier    // Supplier information (optional)
    Processes     []Process    // Manufacturing processes
    Inventory     []Inventory  // Inventory points
    FlowControls  []FlowControl // Push/pull controls
    CreatedAt     time.Time    // Creation timestamp
    UpdatedAt     time.Time    // Last update timestamp
}

Represents a manufacturing or service process.

type Process struct {
    ID         string            // Unique identifier
    Name       string            // Process name
    Type       ProcessType       // Material, Energy, or Data
    Parameters ProcessParameters // Process timing and quality parameters
    Inputs     []string          // Input material/process IDs
    Outputs    []string          // Output material/process IDs
    Resources  []Resource        // Required resources
}

Contains all timing and quality parameters as defined in ISO 22468:2020 Annex A.

type ProcessParameters struct {
    // Time components (all in TimeUnit)
    ProcessTime    float64   // PRT: Processing time
    SetupTime      float64   // ST: Setup/changeover time
    HandlingTime   float64   // HT: Material handling time
    WaitingTime    float64   // WTp: Process waiting time
    AdminTime      float64   // AT: Administrative time
    CycleTime      float64   // CT: Time between completions

    // Quality parameters
    YieldFactor    float64   // YF: 1 - (scrap + rework rates)
    ScrapRate      float64   // SR: Scrap percentage
    ReworkRate     float64   // RR: Rework percentage

    // Additional parameters
    BatchSize      int       // BS: Process batch size
    TimeUnit       TimeUnit  // Unit for time measurements
    Availability   float64   // OA: Operational availability (0.0-1.0)
}

Performs current state analysis and bottleneck detection.

type Analyzer struct {
    // Configuration options
    SensitivityThreshold float64 // Bottleneck detection sensitivity (0.0-1.0)
    IncludeWasteAnalysis bool    // Enable detailed waste analysis
}

// Methods
func NewAnalyzer() *Analyzer
func (a *Analyzer) AnalyzeCurrentState(vs *ValueStream) (*AnalysisResult, error)
func (a *Analyzer) DetectBottlenecks(vs *ValueStream) ([]Bottleneck, error)
func (a *Analyzer) AnalyzeWaste(vs *ValueStream) (*WasteAnalysis, error)

Creates future state designs and improvement opportunities.

type Designer struct {
    // Configuration options
    TargetEfficiency    float64 // Target process efficiency
    MaxImprovements     int     // Maximum improvements to suggest
    IncludeIdealState   bool    // Generate ideal state design
}

// Methods
func NewDesigner() *Designer
func (d *Designer) DesignFutureState(analysis *AnalysisResult, project *Project) (*DesignResult, error)
func (d *Designer) GenerateIdealState(vs *ValueStream) (*ValueStream, error)

Develops implementation plans with SMART measures.

type Planner struct {
    // Configuration options
    MeasureComplexity   MeasureComplexity // Simple, Medium, Complex
    IncludeWorkshops    bool             // Generate workshop plans
    TimelineBuffer      float64          // Timeline buffer percentage
}

// Methods
func NewPlanner() *Planner
func (p *Planner) PlanImplementation(design *DesignResult, project *Project) (*PlanningResult, error)
func (p *Planner) GenerateSMARTMeasures(improvements []ImprovementPotential) ([]Measure, error)

Monitors performance and manages PDCA cycles.

type Assessor struct {
    // Configuration options
    AssessmentPeriod    time.Duration    // Assessment period
    TrendAnalysisPoints int             // Number of data points for trending
    PDCAEnabled         bool            // Enable PDCA cycle management
}

// Methods
func NewAssessor() *Assessor
func (a *Assessor) AssessValueStream(vs *ValueStream, targets map[string]float64, history []PerformanceData) (*Assessment, error)
func (a *Assessor) GenerateActionItems(assessment *Assessment) ([]ActionItem, error)

Performs all KPI calculations according to ISO 22468:2020 Annex A.

type Calculator struct {
    // Configuration options
    Precision       int     // Decimal precision for calculations
    IncludeAdvanced bool    // Calculate advanced KPIs
}

// Methods
func NewCalculator() *Calculator
func (c *Calculator) CalculateKPIs(vs *ValueStream) (map[string]float64, error)
func (c *Calculator) CalculateProcessTime(p *Process) float64
func (c *Calculator) CalculateLeadTime(vs *ValueStream) float64
func (c *Calculator) CalculateValueAddedRatio(vs *ValueStream) float64

The SDK implements all calculation procedures from ISO 22468:2020 Annex A. All calculations follow the exact formulas specified in the standard.

Process Time (PT)
Total time required to complete a process cycle:

PT = PRT + ST + HT + WTp + AT

Where:

• PRT = Processing Time (actual transformation time)
• ST = Setup Time (changeover/setup time)
• HT = Handling Time (material movement time)
• WTp = Process Waiting Time (queue time within process)
• AT = Administrative Time (documentation/reporting time)

Lead Time (LT)
Total time from customer order to delivery:

LT = VAT + NVAT + NNVAT

Where:

• VAT = Value-Added Time (actual processing time)
• NVAT = Non-Value-Added Time (waste time, can be eliminated)
• NNVAT = Necessary Non-Value-Added Time (required waste, e.g., safety buffers)

Value-Added Ratio (VAR)
Percentage of time spent on value-adding activities:

VAR = VAT ÷ LT × 100%

Process Efficiency (PE)
Efficiency of individual processes:

PE = VAT ÷ PT × 100%

Customer Takt Time (CTT)
Rate at which customers require product:

CTT = Operating Time ÷ Customer Demand

Inventory Turns (IT)
How often inventory is replenished:

IT = Customer Demand ÷ Average Inventory Quantity

On-Time In-Full (OTIF)
Delivery performance metric:

OTIF = (Delivered on Time × Delivered In Full) ÷ Total Orders × 100%

Yield Factor (YF)
Quality performance indicator:

YF = 1 - (Scrap Rate + Rework Rate)

Flow Efficiency (FE)
Measure of process flow smoothness:

FE = VAT ÷ LT × 100%

Total Value Stream Efficiency (TVSE)
Overall efficiency across the entire value stream:

TVSE = Σ(VAT) ÷ Σ(LT) × 100%

Process Capacity Utilization (PCU)
How effectively process capacity is used:

PCU = (Actual Output × Standard Time) ÷ Available Time × 100%

Bottleneck Detection Index (BDI)
Identifies constraining processes:

BDI = (Process Cycle Time × Customer Demand) ÷ Process Capacity

Values > 1.0 indicate potential bottlenecks.

The SDK includes standard VSM symbols for mapping and visualization as defined in ISO 22468:2020.

Process Symbols:

• process_box: Standard process box for material transformation
• data_box: Data/information processing
• shipment: Customer/supplier shipment process
• inspection: Quality inspection point

Inventory Symbols:

• inventory_triangle: Inventory/buffer storage
• supermarket: Controlled inventory (kanban)
• fifo_lane: First-in-first-out lane

Information Flow Symbols:

• information_flow: Electronic information flow
• manual_info_flow: Manual information transfer
• production_control: Production scheduling signal
• mrp_erp: MRP/ERP system signal

Material Flow Symbols:

• push_arrow: Push system flow (forecast-driven)
• pull_arrow: Pull system flow (demand-driven)
• go_see_production: Go-see production scheduling

// Get specific symbol information
symbol, exists := vsm.GetSymbol("process_box")
if exists {
    fmt.Printf("Symbol: %s - %s\n", symbol.Code, symbol.Description)
    fmt.Printf("Category: %s\n", symbol.Category)
}

// Get all symbols in a category
processSymbols := vsm.GetSymbolsByCategory(vsm.CategoryProcess)
for _, sym := range processSymbols {
    fmt.Printf("%s: %s\n", sym.Code, sym.Name)
}

// Check if symbol exists
if vsm.SymbolExists("push_arrow") {
    fmt.Println("Push arrow symbol is available")
}

Each symbol contains:

• Code: Unique identifier (string)
• Name: Display name (string)
• Description: Detailed description (string)
• Category: Symbol category (Process, Inventory, Flow, Information)
• Standard: Compliance standard reference
• VisualRepresentation: ASCII art or Unicode symbol

The SDK provides comprehensive serialization support for saving and loading value stream data in JSON format.

type Serializer struct {
    // Configuration options
    PrettyPrint      bool          // Enable pretty-printed JSON
    IncludeMetadata  bool          // Include timestamps and version info
    Compression      CompressionType // JSON, GZIP, or NONE
    Validation       bool          // Validate data during serialization
}

Serialize to JSON string:

serializer := vsm.NewSerializer()

// Serialize value stream to JSON
jsonData, err := serializer.SerializeValueStream(valueStream)
if err != nil {
    log.Fatalf("Serialization failed: %v", err)
}

fmt.Printf("Serialized data length: %d bytes\n", len(jsonData))

Deserialize from JSON string:

// Deserialize value stream from JSON
loadedVS, err := serializer.DeserializeValueStream(jsonData)
if err != nil {
    log.Fatalf("Deserialization failed: %v", err)
}

fmt.Printf("Loaded value stream: %s\n", loadedVS.Name)

Save to file:

// Save value stream to JSON file
err = serializer.SaveToFile(valueStream, "production_line.json")
if err != nil {
    log.Fatalf("Save failed: %v", err)
}

fmt.Println("Value stream saved to production_line.json")

Load from file:

// Load value stream from JSON file
loadedVS, err := serializer.LoadFromFile("production_line.json")
if err != nil {
    log.Fatalf("Load failed: %v", err)
}

fmt.Printf("Loaded value stream with %d processes\n", len(loadedVS.Processes))

Batch operations:

// Serialize multiple value streams
streams := []*vsm.ValueStream{vs1, vs2, vs3}
batchData, err := serializer.SerializeBatch(streams)

// Deserialize multiple value streams
loadedStreams, err := serializer.DeserializeBatch(batchData)

Validation during serialization:

serializer.Validation = true

// This will validate data integrity before serialization
validatedData, err := serializer.SerializeValueStream(valueStream)
if err != nil {
    fmt.Printf("Validation error: %v\n", err)
}

Compressed serialization:

serializer.Compression = vsm.CompressionGZIP

// Save compressed data
err = serializer.SaveToFile(valueStream, "compressed_vsm.json.gz")

This section provides solutions to common issues encountered when using the VSM Go SDK.

Symptoms:

• Command returns network error
• "module not found" error
• Proxy/firewall blocking access

Solutions:

1. Check network connectivity:

   ping github.com

2. Configure Go proxy (if behind corporate firewall):

   go env -w GOPROXY=https://proxy.golang.org,direct

3. Use VPN if corporate network blocks GitHub

4. Manual download (fallback option):

   • Download the repository as ZIP from GitHub
   • Place in $GOPATH/src/github.com/iso22468/
   • Run go mod tidy

Symptoms:

• "cannot find package" error
• IDE shows red squiggles on import statement

Solutions:

1. Verify module installation:

   go list -m github.com/iso22468/vsm-go-sdk

2. Clean module cache:

   go clean -modcache
   go get github.com/iso22468/vsm-go-sdk@latest

3. Check Go version compatibility:

   go version

   Ensure Go 1.19 or later is installed.

Symptoms:

• analyzer.AnalyzeCurrentState() returns empty bottleneck list
• KPI calculations return zero values
• No errors reported but no meaningful output

Solutions:

1. Check value stream completeness:

   // Ensure processes have valid parameters
   for _, process := range vs.Processes {
       if process.Parameters.ProcessTime <= 0 {
           fmt.Printf("Process %s has invalid process time\n", process.ID)
       }
   }

2. Verify customer demand is set:

   if vs.Customer == nil || vs.Customer.Demand <= 0 {
       fmt.Println("Customer demand not properly configured")
   }

3. Check process connections:

   • Ensure process inputs/outputs are properly linked
   • Verify inventory points are correctly positioned

Symptoms:

• SerializeValueStream() returns error
• JSON file is corrupted or unreadable

Solutions:

1. Enable validation:

   serializer := vsm.NewSerializer()
   serializer.Validation = true
   
   data, err := serializer.SerializeValueStream(vs)
   if err != nil {
       fmt.Printf("Validation failed: %v\n", err)
   }

2. Check for circular references:

   • Ensure no circular dependencies in process flows
   • Verify inventory references are valid

3. Handle special characters:

   • Use UTF-8 encoding for all strings
   • Escape special characters in process names

Symptoms:

• Application consumes excessive memory
• Performance degrades with large value streams
• Out of memory errors

Solutions:

1. Optimize analyzer configuration:

   analyzer := vsm.NewAnalyzer()
   analyzer.SensitivityThreshold = 0.8 // Reduce sensitivity for large datasets

2. Process in batches:

   // Analyze processes in chunks
   chunkSize := 50
   for i := 0; i < len(vs.Processes); i += chunkSize {
       end := i + chunkSize
       if end > len(vs.Processes) {
           end = len(vs.Processes)
       }
   
       partialVS := &vsm.ValueStream{
           Processes: vs.Processes[i:end],
           // ... other fields
       }
   
       partialAnalysis, _ := analyzer.AnalyzeCurrentState(partialVS)
       // Process partial results
   }

3. Use streaming serialization for large datasets

Symptoms:

• Calculated ratios don't match expectations
• Negative values where positive expected
• Results don't align with manual calculations

Solutions:

1. Verify time units consistency:

   // Ensure all processes use the same time unit
   for _, process := range vs.Processes {
       if process.Parameters.TimeUnit != vsm.TimeUnitMinutes {
           fmt.Printf("Inconsistent time unit in process %s\n", process.ID)
       }
   }

2. Check parameter ranges:

   • Process times should be positive
   • Yield factors should be between 0.0 and 1.0
   • Efficiency ratios should not exceed 1.0

3. Validate against known benchmarks:

   • Compare with manual calculations for small examples
   • Use example_vsm_workflow.go as reference

// For large value streams, disable unnecessary features
analyzer := vsm.NewAnalyzer()
analyzer.IncludeWasteAnalysis = false // Disable detailed waste analysis

designer := vsm.NewDesigner()
designer.MaxImprovements = 10 // Limit improvement suggestions

// Use concurrent processing for multiple value streams
var wg sync.WaitGroup
results := make(chan *vsm.AnalysisResult, len(valueStreams))

for _, vs := range valueStreams {
    wg.Add(1)
    go func(stream *vsm.ValueStream) {
        defer wg.Done()
        analyzer := vsm.NewAnalyzer()
        result, _ := analyzer.AnalyzeCurrentState(stream)
        results <- result
    }(vs)
}

wg.Wait()
close(results)

If you encounter issues not covered here:

1. Check the example_vsm_workflow.go file for complete examples
2. Review the ISO 22468:2020 standard for methodology questions
3. Search existing issues in the project repository
4. Create a new issue with:
   • Go version and operating system
   • Complete error messages
   • Minimal code example reproducing the issue
   • Expected vs. actual behavior

This SDK is fully compliant with ISO 22468:2020 Value Stream Management standard:

The SDK implements all 8 design principles from "Learning to See":

1. Takt Time: Calculate and use customer takt time to pace production
2. Supermarket: Implement controlled inventory points for pull systems
3. Continuous Flow: Design processes for smooth, uninterrupted flow
4. Pull Systems: Use demand signals to control production
5. Pacemaker: Establish a pacemaker process to control the entire value stream
6. Levelling (Heijunka): Level production mix and volume to reduce variability
7. Release: Control work release to prevent overburdening
8. Continuous Improvement: Establish mechanisms for ongoing kaizen activities

All calculations follow the exact formulas specified in ISO 22468:2020 Annex A:

• Process time components (PRT, ST, HT, WTp, AT)
• Lead time decomposition (VAT, NVAT, NNVAT)
• Performance ratios and efficiency metrics
• Quality and yield calculations
• Inventory and flow metrics

The SDK includes comprehensive validation:

• Parameter range checking
• Formula accuracy verification
• Data integrity validation
• Cross-reference validation
• Standards compliance testing

We welcome contributions to the VSM Go SDK! This section outlines the process for contributing to the project.

• Bug Reports: Report issues via GitHub issues
• Feature Requests: Suggest new features or improvements
• Code Contributions: Submit pull requests with bug fixes or enhancements
• Documentation: Improve documentation, examples, or tutorials
• Testing: Add test cases or improve test coverage

1. Fork and Clone:

   git clone https://github.com/your-username/iso22468-vsm-go-sdk.git
   cd iso22468-vsm-go-sdk

2. Install Dependencies:

   go mod download

3. Run Tests:

   go test ./...

4. Build Examples:

   go build ./example_vsm_workflow.go

• Follow standard Go formatting (go fmt)
• Use meaningful variable and function names
• Add comments for complex algorithms
• Include unit tests for new functionality
• Maintain backward compatibility where possible

• Update README.md for API changes
• Add examples for new features
• Include inline code documentation
• Update this contributing guide as needed

• All tests must pass: go test ./...
• Minimum 80% code coverage for new code
• Include integration tests for complex features
• Test edge cases and error conditions

• Maintain compliance with the VSM standard
• Validate calculations against Annex A formulas
• Preserve backward compatibility with existing VSM models
• Document any deviations from the standard

1. Create a Branch:

   git checkout -b feature/your-feature-name

2. Make Changes:

   • Implement your feature or fix
   • Add/update tests
   • Update documentation

3. Run Quality Checks:

   go vet ./...
   go fmt ./...
   go test ./... -cover

4. Commit Changes:

   git commit -m "Add feature: brief description"

5. Push and Create PR:

   git push origin feature/your-feature-name

   Then create a pull request on GitHub

When reporting issues, please include:

• Go version (go version)
• Operating system and version
• Steps to reproduce the issue
• Expected vs. actual behavior
• Code snippets or example files
• Error messages and stack traces

This project follows a code of conduct to ensure a welcoming environment for all contributors. Please:

• Be respectful and inclusive
• Focus on constructive feedback
• Help newcomers learn and contribute
• Maintain professional communication

This project implements the ISO 22468:2020 Value Stream Management standard and is licensed under the MIT License.

MIT License

Copyright (c) 2025 VSM Go SDK Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

• ISO 22468:2020 - Value stream management (VSM)
  • International Organization for Standardization
  • Geneva, Switzerland

• Rother, M. & Shook, J. (1999) - Learning to See: Value Stream Mapping to Add Value and Eliminate Muda

  • Lean Enterprise Institute
  • Brookline, MA, USA

• Womack, J. P. & Jones, D. T. (1996) - Lean Thinking: Banish Waste and Create Wealth in Your Corporation

  • Free Press
  • New York, NY, USA

• Rother, M. (2010) - Toyota Kata: Managing People for Improvement, Adaptiveness and Superior Results

  • McGraw-Hill
  • New York, NY, USA

• ISO 9001:2015 - Quality management systems
• ISO 14001:2015 - Environmental management systems
• ISO 45001:2018 - Occupational health and safety management systems

• Lean Enterprise Institute - Lean manufacturing resources
• International Organization for Standardization - ISO standards
• Go Programming Language - Go language documentation

Document History

• v1.0 (December 2025) - Initial ISO/IEC/IEEE 26514 compliant documentation