Advanced Solution Design in Infor Mongoose: Best Practices for Model-Driven Development

Infor Mongoose is not just another low-code development tool—it’s a sophisticated, metadata-driven framework that empowers businesses to build robust, scalable applications that integrate deeply with Infor CloudSuite and other ERP platforms. While Mongoose offers rapid development capabilities, leveraging its full potential requires understanding advanced solution design techniques rooted in model-driven principles.

This comprehensive guide explores advanced Mongoose strategies, from application architecture and data modeling to business logic, integration, security, and performance optimization. Whether you’re developing standalone apps or extending existing Infor solutions, this guide is your blueprint for scalable, maintainable, and enterprise-grade Mongoose applications.

Understanding Model-Driven Development in Mongoose

Model-Driven Development (MDD) separates the “what” from the “how.” Rather than writing procedural logic, developers use models to define application behavior and structure. In Mongoose, this includes:

• Forms: Define UI layouts, events, and data bindings
  
• IDOs: Abstract database interactions into manageable business entities
  
• Scripts & Events: Manage business logic declaratively or through code
  
• Permissions: Controlled through layered role-based access
  

By focusing on high-level abstractions, developers achieve greater agility, faster prototyping, and easier maintenance.

Structuring Applications Efficiently in Infor Mongoose

Modular Architecture

Advanced Mongoose design starts with modularity. Applications should be broken into discrete, logically separated modules such as:

• Core: Shared functionality (e.g., authentication, navigation)
  
• Finance: Budgeting, accounting, invoicing features
  
• HR: Employee records, payroll, onboarding workflows
  
• Operations: Inventory, logistics, asset tracking 

Each module should include its own forms, IDOs, scripts, and security groups to enhance encapsulation and scalability.

Naming Conventions

A consistent naming strategy prevents conflict with Infor standard components and improves developer readability. Examples:

• CUST_ prefix for customer-specific modules
  
• HR_EmpForm, FIN_InvoiceForm for domain clarity
  
• EXT_IDO_AssetMgmt for custom IDOs 

Adopt CamelCase or snake_case consistently based on your team’s standards, and document naming schemas in internal wikis.

Metadata Documentation

Infor Mongoose allows comments and descriptions on metadata elements. Use this for:

• Design rationale
  
• Functional requirements
  
• Developer notes
  
• Version history 

Well-documented metadata eases future enhancements and knowledge transfer.

Data Modeling Best Practices

Smart Use of IDOs

Intelligent Data Objects (IDOs) are the interface between your forms and the database. Poorly designed IDOs can cripple performance and create maintenance headaches.

Tips for Optimized IDO Design:

• Only expose necessary fields
  
• Avoid unnecessary joins; split into view-level IDOs when needed
  
• Enable paging and filtering for large datasets
  
• Use IDO methods (LoadCollection, UpdateCollection) effectively 

Avoid mixing transactional and reporting logic within the same IDO.

Data Relationships and Referential Integrity

Data integrity should be enforced at both the DB and Mongoose levels:

• Use mandatory foreign keys for critical links (e.g., Employee → Department)
  
• Configure delete cascades where appropriate
  
• Create custom validations to catch business-specific relationship rules (e.g., no inactive users in active projects) 

Master and Transaction Table Separation

Separate master data (customers, products) from transactional data (orders, time logs). This helps:

• Ensure data normalization
  
• Improve reporting
  
• Reduce duplication
  
• Simplify data governance 

Use IDO collections with nested child tables to model hierarchical data cleanly.

Building Reusable Components

Form Templates

Design form templates for repeated layouts—such as search screens, detail views, or workflow forms. A template can define:

• Header and footer structure
  
• Navigation bars
  
• Consistent branding
  
• Sectional layout standards 

Control Reusability

Create reusable custom controls and form objects such as:

• Date/time pickers with validation
  
• Dropdowns tied to code tables
  
• Search/look-up forms using shared logic
  

You can package and version these components for inclusion in multiple modules.

Script Libraries

Centralize business logic that spans across forms:

• Validation rules (e.g., required fields, date ranges)
  
• Notification handlers (alerts, confirmations)
  
• Role-based UI adjustments
  

This improves consistency and reduces redundancy across your app ecosystem.

Business Logic and Event Handling

Declarative vs. Procedural Logic

Prefer declarative logic (via event definitions, rules, and conditions) for standard use cases:

• Setting default values
  
• Controlling field visibility
  
• Validating inputs
  

For complex scenarios—like conditional workflows, batch processing, or cross-form calculations—use procedural logic via:

• WinStudio event handlers
  
• Embedded scripts
  
• Server-side logic
  

Event Sequencing

Order matters. For example, a Field OnChange event might conflict with a Form OnValidate event if not sequenced correctly. Maintain control by:

• Documenting event chains
  
• Using naming conventions for clarity (e.g., btnSave_OnClick)
  

Transaction Safety

Use server-side scripts or stored procedures for multi-step updates. Ensure:

• Transactions are atomic
  
• Rollbacks are triggered on failure
  
• Logging captures both successes and errors
  

This ensures data integrity, especially in mission-critical workflows.

Integration and Extensibility

Infor ION Integration

Infor ION is a middleware layer that connects CloudSuite products and third-party systems.

Best practices for Mongoose–ION integration:

• Leverage BODs for standardized business messages
  
• Use document flows for routing and orchestration
  
• Implement alerts for exceptions or retries 

For example, a sales order created in Mongoose can automatically push to Infor LN via ION using SalesOrder BOD.

RESTful APIs

Mongoose can both consume and expose APIs. To design robust RESTful endpoints:

• Use token-based or OAuth2 authentication
  
• Implement rate limiting if external traffic is expected
  
• Expose only required IDO fields
  
• Use Swagger for documentation
  

Common use cases include mobile app backends, customer portals, or partner system integrations.

JavaScript and HTML Extensions

Advanced UI requirements (e.g., data visualizations, drag-and-drop scheduling, WYSIWYG editors) can be met using:

• Embedded JavaScript
• External libraries like Chart.js, FullCalendar, D3.js
  

Ensure these are sandboxed properly and conform to corporate security policies.

Security and Governance

Role-Based Access Control (RBAC)

Define user roles carefully to limit access:

• Assign data roles to control what records users see
• Use functional roles for form-level access
  
• Combine roles for granular control (e.g., Finance_ReadOnly vs. Finance_Admin) 

Audit role changes regularly to comply with compliance policies.

Row-Level Security

Restrict access to individual records based on:

• Business unit
  
• Region
  
• Department
  
• User group 

Use conditional filtering or IDO method overrides to enforce this security model.

Audit Trails and Data Lineage

Enable built-in Mongoose audit features or create custom logging tables to track:

• Who made what change
• When it was made
• What was changed 

Use this for SOX compliance, GDPR, or general accountability.

Data Masking and Encryption

Mask sensitive fields (e.g., SSN, credit card info) in both forms and API outputs. Use encrypted fields in the database or encryption-at-rest policies depending on system design.

Performance Optimization

Load Time Optimization

Forms can become bloated with controls, subforms, and datasets. To improve load time:

• Load controls and datasets on-demand
• Defer loading of heavy grids
• Limit visible records using filters and pagination
  

Efficient Queries

Slow IDO responses often come from poor SQL generation. Fix this by:

• Reviewing SQL execution plans
• Adding indexes on frequently searched columns
• Avoiding wildcards and full-table scans 

Use the Mongoose Profiler for SQL Server Profiler for detailed analysis.

Caching Strategies

Implement caching for:

• Static lookup tables
• Reference data
• User preferences 

Use system events to invalidate cache after updates to avoid stale data issues.

Background Processing

Offload heavy tasks to background workers or asynchronous jobs using:

• Mongoose Background Tasks
• External process schedulers
• SQL Agent jobs for database tasks

This ensures the UI remains responsive during long-running tasks.

Final Thoughts and Recommendations

Advanced solution design in Infor Mongoose is both an art and a science. It requires a strategic mindset, attention to best practices, and a willingness to continuously refine based on performance, scalability, and user feedback.

Summary of Best Practices

Internal Links & Resources

For more in-depth topics, check out:

• Infor ION Integration Guide
• Understanding IDOs in Mongoose
• Security Strategies for Mongoose Apps
• Performance Optimization Tips 

Need expert guidance or implementation support?
Sama Consulting Inc. offers comprehensive consulting services for Infor Mongoose application design, development, integration, and performance tuning.