​

Best Practices

This guide provides recommendations and best practices for working with Infactory to build efficient, reliable, and maintainable data query systems.

​

Data Connection Best Practices

Getting your data connection right is the foundation of a successful Infactory implementation.

​

Schema Design

• Use Clear Column Names: Choose descriptive names for your database columns that reflect their content
• Consistent Naming Conventions: Use consistent naming patterns across your database schema
• Add Comments in Database: Where possible, add comments to your database columns that explain their purpose
• Consider Data Types: Use appropriate data types for your columns to help Infactory understand your data better

​

Data Quality

• Representative Data: Ensure your database contains representative sample data during setup
• Avoid Empty Tables: Tables without data won’t generate meaningful query templates
• Clean Data: Remove or fix inconsistent, incorrect, or duplicate data
• Normalize When Possible: Well-normalized data often leads to better query generation

​

Connection Security

• Read-Only Connections: When possible, connect Infactory using read-only database credentials
• Specific Permissions: Grant access only to the tables and views that are needed
• Consider Views: Use database views to limit which fields and records Infactory can access

​

Query Building Best Practices

Creating effective queries is crucial for getting accurate and useful responses.

​

Query Design

• One Purpose Per Query: Design each query to serve one specific type of question
• Descriptive Names: Give your queries clear names that describe their purpose
• Comprehensive Comments: Add detailed comments explaining what each query does and how it works
• Test with Edge Cases: Verify your queries work correctly with extreme or unusual parameter values

​

Parameter Usage

• Default Values: Where appropriate, provide sensible default values for parameters
• Input Validation: Add code to validate parameter values and handle invalid inputs gracefully
• Clear Parameter Names: Use descriptive names for parameters to make them easy to understand
• Document Parameter Types: Clearly document what type of data each parameter accepts

​

Query Optimization

• Efficient Data Loading: Only load the data you need for the query
• Early Filtering: Apply filters as early as possible in your query logic
• Limit Results: When appropriate, limit the number of results returned
• Index Awareness: Design queries that can take advantage of your database indexes

​

Deployment Best Practices

How you deploy your queries affects their availability, performance, and security.

​

Deployment Strategy

• Progressive Deployment: Start with a core set of queries and expand based on user needs
• Test Before Deploy: Always test queries thoroughly before deploying them
• Deployment Phases: Consider using different projects for development, testing, and production
• Version Tracking: Keep track of query versions and changes

​

API Security

• API Key Rotation: Regularly rotate your API keys
• Separate Keys Per Environment: Use different API keys for development, testing, and production
• Monitor Usage: Keep track of API usage to detect unusual patterns
• Rate Limiting: Implement rate limiting in your application to prevent accidental abuse

​

Performance Monitoring

• Track Response Times: Monitor how long your queries take to execute
• Identify Slow Queries: Keep an eye out for queries that are consistently slow
• Optimize Popular Queries: Focus optimization efforts on the most frequently used queries
• Cache Common Results: Consider caching results for frequently asked questions

​

Integration Best Practices

Integrating Infactory with your applications effectively requires careful planning.

​

Application Integration

• Unified Endpoint for Chat Interfaces: Use the unified query endpoint for conversational interfaces
• Direct Endpoint for Specific Functions: Use direct query endpoints for predefined application features
• Proper Error Handling: Implement robust error handling in your integration
• Clear User Feedback: Provide clear feedback to users when queries can’t be answered

​

UI Design

• Guide User Questions: Design your UI to guide users toward asking questions that can be answered
• Show Available Topics: Let users know what kinds of questions the system can answer
• Provide Examples: Show example questions to help users get started
• Visualize Results: Use appropriate visualizations for different types of query results

​

Hybrid Approaches

• Combine with LLMs: Consider using LLMs to provide natural language summaries of Infactory’s structured data results
• Pre-process Questions: Use LLMs to reformulate ambiguous user questions before sending them to Infactory
• Enhance Results: Use LLMs to enhance Infactory’s structured data with additional context or explanations
• Handle Fallbacks: Use LLMs as a fallback when Infactory can’t answer a question

​

Maintenance Best Practices

Keeping your Infactory implementation up-to-date and running smoothly requires ongoing attention.

​

Regular Review

• Query Usage Analysis: Regularly review which queries are being used most frequently
• Failed Query Analysis: Identify common questions that aren’t being answered successfully
• Performance Review: Check for queries that are becoming slower over time
• Coverage Gap Identification: Look for types of questions that your current queries don’t address

​

Continuous Improvement

• Expand Query Coverage: Create new queries to address common unanswerable questions
• Refine Existing Queries: Update queries that aren’t providing optimal results
• Update Data Connections: Keep your data connections in sync with changes to your database schema
• Incorporate User Feedback: Use feedback from actual users to guide improvements

​

Documentation

• Keep Documentation Current: Update your internal documentation as you add or modify queries
• Document Common Questions: Maintain a list of example questions that each query can answer
• Track Changes: Keep a log of changes made to queries and data connections
• Document Limitations: Be clear about what types of questions your system can’t answer

​

Project Planning Best Practices

Planning your Infactory implementation properly sets you up for success.

​

Scope Definition

• Start Focused: Begin with a clear, limited scope rather than trying to cover everything
• Define Success Criteria: Establish clear metrics for what makes your implementation successful
• Identify Key Questions: Determine the most important questions your system should answer
• Prioritize Use Cases: Focus first on the use cases that provide the most value

​

Stakeholder Engagement

• Involve Subject Matter Experts: Work with people who understand the data and its business context
• Get User Input Early: Involve end users in determining what questions they want to ask
• Regular Demos: Show progress regularly to stakeholders to get feedback
• Educate Users: Ensure users understand how to effectively interact with the system

​

Scaling Considerations

• Plan for Growth: Consider how your needs might grow over time
• Data Volume Strategy: Have a plan for handling increasing data volumes
• Query Complexity Evolution: Expect to develop more sophisticated queries as users become familiar with the system
• Cross-Project Knowledge Sharing: Share lessons learned across different Infactory projects

​

Advanced Usage Tips

Take your Infactory implementation to the next level with these advanced techniques.

​

Custom Data Preprocessing

• ETL Processes: Consider implementing ETL processes to prepare your data optimally for Infactory
• Derived Tables: Create derived tables or views that make complex data easier to query
• Aggregation Tables: Pre-aggregate data to improve performance for common analytical queries
• Denormalization: In some cases, denormalizing data can make it easier to query

​

Query Template Patterns

• Reusable Code Snippets: Develop a library of code snippets for common query patterns
• Parameter Standardization: Standardize how parameters are handled across similar queries
• Complex Analysis Templates: Create templates for more sophisticated analytical queries
• Multi-Step Query Chains: Design patterns for queries that build on the results of other queries

​

Testing Framework

• Automated Testing: Develop automated tests for your critical queries
• Regression Testing: Test queries with previous inputs when making changes
• Performance Benchmarking: Establish baselines for query performance
• User Acceptance Testing: Develop a process for having stakeholders validate query results

​

Next Steps

Now that you understand the best practices for working with Infactory, you’re ready to build robust, efficient data query systems. Remember that these best practices will evolve as you gain experience with your specific use cases.

For more detailed information on specific aspects of Infactory, check out our other guides: