This repository provides comprehensive, workflow-based AL development guidelines for Microsoft Dynamics 365 Business Central development. The instructions are organized by development workflows to create meaningful organization, good indexes, and eliminate duplicate content while maintaining GitHub Copilot accessibility.

• Workflow-Based Organization: Guidelines organized by development lifecycle phases
• Meaningful File Names: Descriptive, purpose-driven naming for enhanced discoverability
• Single Source of Truth: Eliminated duplication with cross-references to shared standards
• GitHub Copilot Integration: All instruction files optimized for AI assistant accessibility
• Comprehensive Navigation: Multiple pathways to find relevant guidance quickly

1. Understand the Structure: Review the Workflow-Based Organization below
2. Choose Your Starting Point: Navigate to the workflow that matches your current development phase
3. Reference Standards: Check SharedGuidelines for cross-cutting standards that apply to all workflows
4. Follow the Flow: Use workflow integration guidance to transition between development phases

Starting a New Project:

1. Begin with SharedGuidelines/Configuration/core-principles
2. Move to CoreDevelopment for AL fundamentals
3. Apply SharedGuidelines/Standards throughout development

Adding Tests:

1. Review CoreDevelopment patterns being tested
2. Follow TestingValidation/testing-strategy
3. Use SharedGuidelines/Standards for consistent test code

Performance Issues:

1. Check PerformanceOptimization for optimization techniques
2. Reference CoreDevelopment/object-patterns for efficient patterns
3. Validate with TestingValidation approaches

Purpose: AL language fundamentals and object development patterns

• al-development-guide.md - Comprehensive AL language guidance and development practices
• coding-standards.md - Code structure and formatting standards
• object-patterns.md - Table, page, codeunit, and other AL object patterns

When to use: Creating new AL objects, implementing business logic, following AL best practices

Purpose: Testing strategies and quality assurance processes

• testing-strategy.md - Comprehensive testing methodology and frameworks
• test-data-patterns.md - Test data generation and management
• quality-validation.md - Linting, code review, and validation processes

When to use: Writing tests, validating code quality, ensuring compliance with standards

Purpose: Integration patterns and deployment strategies

• integration-patterns.md - Business Central integration and API development
• accessibility-standards.md - Procedure accessibility and testability requirements

When to use: Integrating with external systems, deploying extensions, ensuring accessibility

Purpose: Performance tuning and optimization techniques

• optimization-guide.md - Database performance, UI optimization, and monitoring

When to use: Optimizing existing code, improving performance, addressing bottlenecks

Purpose: AppSource marketplace compliance and publishing

• appsource-requirements.md - Marketplace requirements and publishing workflow

When to use: Preparing extensions for AppSource, ensuring marketplace compliance

Purpose: Cross-cutting standards that apply across all workflows

• naming-conventions.md - Comprehensive naming rules for all AL objects
• code-style.md - Code formatting and style guidelines
• error-handling.md - Error handling patterns and best practices

• core-principles.md - Fundamental AL development principles
• ai-assistant-guidelines.md - GitHub Copilot configuration and behavior

By Development Phase:

• Starting new project → CoreDevelopment
• Writing tests → TestingValidation
• Adding integrations → IntegrationDeployment
• Fixing performance → PerformanceOptimization
• Publishing to AppSource → AppSourcePublishing

By Topic:

• Object naming → SharedGuidelines/Standards/naming-conventions
• Code formatting → SharedGuidelines/Standards/code-style
• Error handling → SharedGuidelines/Standards/error-handling
• Core principles → SharedGuidelines/Configuration/core-principles

By AL Object Type:

• Tables → CoreDevelopment/object-patterns + SharedGuidelines/Standards/naming-conventions
• Pages → CoreDevelopment/al-development-guide + IntegrationDeployment/accessibility-standards
• Codeunits → CoreDevelopment/object-patterns + TestingValidation/testing-strategy
• Test Objects → TestingValidation/ + SharedGuidelines/Standards/

Quick Reference:

• All instruction files use .md extension for GitHub Copilot recognition
• Each workflow folder contains comprehensive README with file descriptions
• Cross-references link related content across workflows

By Common Development Tasks:

• Fixing Linter Errors: TestingValidation/quality-validation
• Performance Issues: PerformanceOptimization/optimization-guide
• Naming Questions: SharedGuidelines/Standards/naming-conventions
• Error Handling: SharedGuidelines/Standards/error-handling
• Code Style Questions: SharedGuidelines/Standards/code-style

By Development Context:

• New Feature Development: CoreDevelopment → TestingValidation
• Integration Projects: IntegrationDeployment + SharedGuidelines/Standards
• AppSource Preparation: AppSourcePublishing + ALL previous workflows
• Code Reviews: SharedGuidelines/Standards + TestingValidation/quality-validation

Search Keywords for GitHub/IDE:

• AL Language: AL, Business Central, Dynamics 365, table, page, codeunit, report
• Development Process: testing, validation, integration, performance, optimization
• Quality: linting, error handling, naming conventions, code style
• Business Central Concepts: extensions, AppSource, APIs, accessibility

• Table Creation: CoreDevelopment/object-patterns | SharedGuidelines/Standards/naming-conventions
• Page Development: CoreDevelopment/object-patterns | CoreDevelopment/coding-standards
• Codeunit Patterns: CoreDevelopment/object-patterns | SharedGuidelines/Standards/error-handling
• Report Development: CoreDevelopment/object-patterns | CoreDevelopment/al-development-guide

• Naming Conventions: SharedGuidelines/Standards/naming-conventions | CoreDevelopment/coding-standards
• Code Style: SharedGuidelines/Standards/code-style | CoreDevelopment/coding-standards
• Error Handling: SharedGuidelines/Standards/error-handling | CoreDevelopment/al-development-guide
• Linter Validation: TestingValidation/quality-validation | SharedGuidelines/Standards/code-style

• Testing Strategy: TestingValidation/testing-strategy | TestingValidation/quality-validation
• Test Data Generation: TestingValidation/test-data-patterns | TestingValidation/testing-strategy
• Quality Validation: TestingValidation/quality-validation | SharedGuidelines/Standards/code-style
• X Prefix Requirements: TestingValidation/test-data-patterns | TestingValidation/testing-strategy

• Variable Declaration: SharedGuidelines/Standards/naming-conventions | SharedGuidelines/Standards/code-style
• Text Constants: SharedGuidelines/Standards/code-style | CoreDevelopment/coding-standards
• Performance Patterns: SharedGuidelines/Standards/code-style | CoreDevelopment/al-development-guide
• Object Qualification: SharedGuidelines/Standards/code-style | CoreDevelopment/al-development-guide

Phase 1: Start with SharedGuidelines/Configuration/core-principles for foundational understanding
Phase 2: Apply CoreDevelopment patterns for object creation and development
Phase 3: Implement TestingValidation for quality assurance
Phase 4: Use PerformanceOptimization for optimization
Phase 5: Follow AppSourcePublishing for marketplace compliance
Always: Reference SharedGuidelines/Standards for consistent standards

AL Development Methodology - Integrated Workflow Architecture

┌─────────────────────────────────────────────────────────────────────────────┐
│                           SharedGuidelines                                 │
│                    ┌─────────────┬─────────────┐                           │
│                    │  Standards/ │Configuration│                           │
│                    │    ┌────────┴─────────┐   │                           │
│                    │    │ All Workflows   │   │                           │
│                    │    │ Reference These  │   │                           │
│                    │    └─────────┬────────┘   │                           │
└────────────────────┴──────────────┼────────────┴───────────────────────────┘
                                    │
                   ┌────────────────┼────────────────┐
                   ▼                ▼                ▼
          ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
          │ CoreDevelopment │ │IntegrationDeploy│ │                 │
          │                 │ │                 │ │                 │
          │ • Objects       │ │ • APIs          │ │                 │
          │ • Business Logic│ │ • Accessibility │ │                 │
          │ • Standards     │ │ • Deployment    │ │                 │
          └─────────┬───────┘ └─────────┬───────┘ │                 │
                    │                   │         │                 │
                    ├───────────────────┼─────────▼                 │
                    │                   │ ┌─────────────────┐       │
                    │                   └─│ TestingValidation│       │
                    │                     │                 │       │
                    │                     │ • Quality       │       │
                    │                     │ • Validation    │       │
                    │                     │ • Test Data     │       │
                    │                     └─────────┬───────┘       │
                    │                               │               │
                    └───────────────────────────────┼───────────────┘
                                                    │
                                                    ▼
                                        ┌─────────────────┐
                                        │PerformanceOptim │
                                        │                 │
                                        │ • Optimization  │
                                        │ • Monitoring    │
                                        │ • Benchmarks    │
                                        └─────────┬───────┘
                                                  │
                                                  ▼
                                        ┌─────────────────┐
                                        │AppSourcePublish │
                                        │                 │
                                        │ • Compliance    │
                                        │ • Documentation │
                                        │ • Marketplace   │
                                        └─────────────────┘

Integration Flow: All workflows ← SharedGuidelines → Foundation → Testing → Optimization → Publishing
Cross-Flow: Integration patterns apply throughout all workflow phases

• SharedGuidelines ↔ All Workflows: Universal standards and principles foundation
  • Core principles guide all development decisions and architectural choices
  • Naming conventions ensure consistency across all objects and components
  • Code style standards maintain quality and readability throughout development
  • Error handling patterns provide robust exception management across all scenarios

• CoreDevelopment ← SharedGuidelines: Development uses shared standards as foundation

  • Standard patterns inform object design and business logic implementation
  • Quality practices ensure professional development from project inception
  • Consistent approaches support maintainable and scalable AL applications

• IntegrationDeployment ↔ All Workflows: Integration considerations apply throughout development

  • ↔ CoreDevelopment: Integration patterns built into object design and development
  • ↔ TestingValidation: Integration testing validates external connectivity and APIs
  • ↔ PerformanceOptimization: Integration performance optimization for scalability
  • ↔ AppSourcePublishing: Integration compliance requirements for marketplace

• TestingValidation ← CoreDevelopment: Testing validates development patterns and implementations

  • Object structures enable comprehensive test coverage and validation scenarios
  • Business logic provides test cases and quality validation opportunities
  • Development standards support automated testing and quality assurance processes

• TestingValidation → PerformanceOptimization: Testing provides baseline metrics for optimization

  • Performance test results identify optimization opportunities and priorities
  • Quality validation ensures optimizations maintain functionality and reliability
  • Test automation supports continuous optimization and quality monitoring

• PerformanceOptimization ← Multiple Workflows: Optimization builds on foundation quality

  • ← CoreDevelopment: Quality objects provide optimization baseline and opportunities
  • ← TestingValidation: Performance metrics guide optimization priorities and validation
  • ← IntegrationDeployment: Integration performance optimization for external systems

• AppSourcePublishing ← All Workflows: Marketplace publishing requires comprehensive quality

  • ← CoreDevelopment: Professional code quality meets marketplace standards
  • ← TestingValidation: Comprehensive testing demonstrates application reliability
  • ← IntegrationDeployment: Accessibility and integration compliance for marketplace
  • ← PerformanceOptimization: Performance benchmarks meet marketplace requirements

1. Foundation Phase: Start with SharedGuidelines/Configuration/core-principles

   • Establish development philosophy and quality objectives
   • Configure AI assistant settings for optimal development support
   • Review standards and conventions for consistent application

2. Development Phase: Use CoreDevelopment with SharedGuidelines/Standards

   • Implement objects and business logic following established patterns
   • Apply naming conventions and code style standards consistently
   • Integrate error handling patterns throughout implementation

3. Quality Assurance Phase: Apply TestingValidation processes

   • Validate development work through comprehensive testing strategies
   • Apply quality validation processes and compliance checking
   • Generate test data and validate business logic implementations

4. Integration Phase: Follow IntegrationDeployment when needed

   • Implement API patterns and external system connectivity
   • Apply accessibility standards for inclusive user experience
   • Validate integration patterns and deployment readiness

5. Optimization Phase: Use PerformanceOptimization for performance tuning

   • Profile application performance and identify optimization opportunities
   • Apply performance optimization patterns while maintaining quality standards
   • Monitor and validate performance improvements against established baselines

6. Publishing Phase: Complete AppSourcePublishing for marketplace

   • Validate comprehensive compliance with AppSource technical requirements
   • Prepare documentation and support processes for marketplace submission
   • Ensure all previous workflow outputs meet marketplace quality standards

Prerequisites for Transition:

• Objects implemented following SharedGuidelines naming conventions
• Business logic complete with proper error handling patterns
• Code style standards applied consistently throughout implementation
• Development documentation complete and up-to-date

Transition Process:

1. Quality Validation Preparation: Review code against SharedGuidelines standards
2. Test Strategy Planning: Identify testing scenarios based on business logic complexity
3. Test Data Generation: Create test data following established prefixing patterns
4. Validation Execution: Apply systematic testing and quality validation processes

Prerequisites for Transition:

• Comprehensive testing completed with documented results and coverage
• Quality validation passed with acceptable metrics and compliance
• Performance baseline established through testing processes
• Test automation implemented for regression prevention

Transition Process:

1. Performance Analysis: Review test results to identify optimization opportunities
2. Baseline Documentation: Establish current performance metrics for comparison
3. Optimization Planning: Prioritize optimization work based on test-identified bottlenecks
4. Validation Strategy: Plan performance validation approach maintaining quality standards

• Naming Conventions: Applied systematically across all objects, procedures, and components

  • CoreDevelopment: Object and procedure naming for clarity and consistency
  • TestingValidation: Test object naming with appropriate prefixes for isolation
  • IntegrationDeployment: API and integration component naming for external clarity
  • PerformanceOptimization: Maintaining naming clarity during optimization work
  • AppSourcePublishing: Enhanced naming standards for marketplace compliance

• Error Handling Standards: Consistent exception management across all development phases

  • CoreDevelopment: Business logic error handling and user experience protection
  • TestingValidation: Test failure scenarios and validation error management
  • IntegrationDeployment: Integration error handling and external system resilience
  • PerformanceOptimization: Performance-focused error handling with minimal overhead
  • AppSourcePublishing: User-friendly error messages and marketplace-appropriate handling

• Single Source of Truth: SharedGuidelines provides authoritative standards referenced by all workflows
• Workflow Connectivity: Each workflow provides outputs that inform and enable subsequent workflows
• Quality Progression: Quality standards increase progressively through workflow phases
• Comprehensive Coverage: Integration considerations apply throughout entire development lifecycle

• Universal Standards: SharedGuidelines standards apply to every workflow without exception
• Progressive Enhancement: Standards application becomes more rigorous toward marketplace publishing
• Consistent Reference: All workflows reference SharedGuidelines for authoritative guidance
• Quality Maintenance: Standards compliance maintained throughout optimization and enhancement phases

For comprehensive guidance on implementing workflow integration effectively, see the Workflow Integration Best Practices Guide which provides:

• Detailed Integration Patterns: Complete examples of workflow connectivity and communication
• Practical Implementation Examples: Real-world scenarios demonstrating integrated workflow application
• Quality Gate Guidelines: Effective validation approaches for workflow transitions
• Common Integration Challenges: Solutions for typical integration problems and approaches
• Cross-Workflow Standards Usage: Detailed patterns for consistent standards application

The integration guide complements individual workflow documentation by providing the holistic view necessary for professional AL development methodology implementation.

Purpose-Driven Naming: Files named by function, not technical structure

• quality-validation.md (function) vs linter_check.md (technical)
• al-development-guide.md (purpose) vs al_code.md (technical)

Workflow Context: Files grouped by when they're used in AL development lifecycle

• Development phase files in CoreDevelopment
• Testing phase files in TestingValidation
• Cross-cutting standards in SharedGuidelines

Multiple Navigation Paths: Find content through:

• Workflow-based browsing (CoreDevelopment → specific files)
• Topic-based search (error handling → SharedGuidelines/Standards/error-handling)
• Development phase navigation (testing → TestingValidation)

Cross-Reference Network: Related content linked rather than duplicated

• Single source of truth in SharedGuidelines
• Workflow-specific guidance references shared standards
• Clear integration points between workflows

Adding New Content:

1. Identify Workflow: Determine which business workflow the content supports
2. Check SharedGuidelines: Verify if content is cross-cutting or workflow-specific
3. Avoid Duplication: Reference existing content rather than duplicating
4. Maintain AL Headers: Ensure all .md files have proper applyTo: '**/*.al'

Modifying Existing Content:

1. Single Source Rule: Only update content in its primary location
2. Update Cross-References: Verify all references to modified content remain accurate
3. Test GitHub Copilot: Ensure AI can still access and apply modified content
4. Validate Links: Check that all internal links continue to work

• GitHub Copilot Integration: All content must support AI assistant integration
• Meaningful Names: File names must be purpose-driven and descriptive
• Cross-References: Prefer references over content duplication
• Workflow Integrity: Each workflow must maintain clear business purpose
• Practical Examples: Include AL code samples and real-world scenarios

CoreDevelopment: Focus on AL language fundamentals and core patterns TestingValidation: Emphasize quality assurance and testing strategies IntegrationDeployment: Cover integration patterns and accessibility PerformanceOptimization: Address performance tuning and optimization AppSourcePublishing: Ensure marketplace compliance and standards SharedGuidelines: Maintain cross-cutting standards that apply everywhere

Standardized File Structure: All instruction files use .md extension for consistent AI recognition Workflow Context: AI assistants can easily navigate from high-level workflows to specific implementation guidance Cross-Reference Network: Related content linked to provide comprehensive context without duplication

Meaningful Organization: AI can quickly locate relevant guidelines based on development context Single Source of Truth: No conflicting guidance - clear standards referenced across workflows Progressive Detail: From overview to implementation details through workflow hierarchy

• Consistent Headers: All instruction files include proper applyTo: '**/*.al' metadata
• Cross-Workflow References: Clear navigation between related concepts
• Practical Examples: Code samples and implementation patterns for AI application
• Search Optimization: Keywords and topics integrated for enhanced discoverability

✅ Meaningful File Names: All files have descriptive, purpose-driven names that clearly indicate their function
✅ Good Indexes: Comprehensive navigation and workflow-based organization for enhanced discoverability
✅ No Duplication: Single source of truth for all standards and guidelines with cross-references
✅ GitHub Copilot Integration: All instruction files accessible and properly formatted for AI assistants
✅ Workflow Organization: Logical business process organization matching AL development lifecycle
✅ Enhanced Navigation: Multiple pathways to find information (by phase, topic, object type, task)

• 🏠 Main README - This navigation hub
• 📋 All Workflows - Navigate using sections above
• 🔗 SharedGuidelines - Cross-cutting standards
• 🎯 Quick Start - Get started immediately

1. Check workflow README files for detailed guidance on specific development phases
2. Review SharedGuidelines for cross-cutting standards and common patterns
3. Use meaningful file names to locate specific guidance quickly
4. Follow cross-references for related content and comprehensive context
5. Reference navigation guides above for multiple discovery pathways

• CoreDevelopment - AL fundamentals and object patterns
• TestingValidation - Testing strategies and quality assurance
• IntegrationDeployment - Integration and deployment guidance
• PerformanceOptimization - Performance tuning and optimization
• AppSourcePublishing - Marketplace compliance and publishing
• SharedGuidelines - Cross-cutting standards and configuration

Repository Structure: Workflow-based organization for enhanced AL development productivity and GitHub Copilot integration.