Deployment Readiness

​

How to Ensure Deployment Readiness

​

1. Check and Review Performance

1

Access Performance Insights

From the Library tab in the left-hand navigation, select Performance Insights.

2

Review Key Metrics

Analyze your backend’s performance across different time periods (last 24 hours, 7 days, or 30 days):

• Average Execution Time: How long does each function or API take to run on average?
• Total Execution Count: Which endpoints are being called most frequently?
• Resource-Intensive Operations: Identify the top 5 slowest database queries or functions.

Focus on:

• API endpoints that will receive high traffic
• Database queries (especially Query All Records operations)
• External API calls or Lambda functions
• Background tasks that process large datasets

3

Optimize Slow Operations

For any operations that seem slow or resource-intensive:

• Review the function stack to identify inefficiencies
• Optimize database queries using filters, pagination, or indexes
• Consider caching frequently accessed data
• Break down complex operations into smaller, parallelizable tasks
• Use mocking responses for external API calls during testing

4

Monitor Request History

Review your Request History to:

• Identify failed API calls and their causes
• Check average runtime across all endpoints
• Review input/output sizes to ensure data payloads are reasonable
• Filter by duration to spot performance outliers

​

2. Build and Run Unit & Workflow Tests

1

Create Unit Tests for Individual Endpoints

Build Unit Tests for each critical API endpoint and custom function:

• From any API or function, use Run & Debug to test with sample inputs
• Once you achieve the desired result, click Create Unit Test
• Define Expects statements to validate the output (e.g., “response.authToken is defined”)
• Add multiple expect statements to test different aspects of the response

Best Practices:

• Test both success scenarios (valid inputs) and failure scenarios (invalid inputs, missing data, etc.)
• Use mock responses for external API calls to ensure consistent, fast tests
• Set up auth token handling to avoid expiration issues during testing

2

Build Workflow Tests for User Flows

Create Test Suites (Workflow Tests) to validate multi-step processes:

• From Library > Workflow Tests, create a new test suite
• Add Run Stack functions to call your APIs in sequence (e.g., signup → login → purchase → confirmation email)
• Add Test Expression functions to validate each step’s output
• Test complete user journeys from start to finish

Example workflow tests:

• User registration → Email verification → Profile setup
• Add to cart → Apply coupon → Checkout → Payment → Order confirmation
• Data import → Processing → Validation → Export

3

Run All Tests and Review Coverage

From the Unit Tests page in your Library:

• Click Run Test Suites to execute all tests at once
• Review your coverage percentage (what % of your function stacks have tests)
• Check your success rate (what % of tests are passing)
• Filter by “Failed Only” to quickly identify and fix issues

Goal: Aim for 100% coverage of critical paths and 100% success rate before deployment.

​

3. Use a Test Data Source to Dry-Run Your Application

1

Create a Test Data Source

• From the left-side navigation, click on your current data source indicator (e.g., “Live”)
• Click + Add Data Source
• Give it a descriptive name like “Test” or “Staging”
• Assign a distinct color (this color will appear throughout Xano to remind you which data source you’re using)

2

Populate Your Test Data Source

You have several options:Option 1: Migrate from Live

• Go to Manage Data Sources > Migrate
• Select your live data source as the source
• Select your test data source as the destination
• Choose which tables to migrate
• This creates a copy of your live data for testing

Option 2: Create Sample Data

• Manually add representative test records
• Use realistic data that mirrors production scenarios
• Include edge cases (empty strings, null values, maximum lengths, etc.)

Option 3: Start Empty

• For workflow tests that only add data, you can start with an empty database

3

Switch to Your Test Data Source

• Click the data source indicator in the left navigation
• Select your test data source from the list
• All Run & Debug operations, unit tests, and workflow tests will now use test data

Switching data sources in Xano only affects your development work—it does not change what your live application uses.

4

Dry-Run Your Application Internally

• Run through typical user workflows manually using Run & Debug
• Execute your unit tests and workflow tests against the test data
• Make changes and iterate without fear of corrupting production data
• Test destructive operations (deletes, bulk updates) safely

5

Connect a Test Frontend (Optional)

If you have a frontend application:

• Deploy a separate staging/test version of your frontend
• Use the X-Data-Source header in API requests to target your test data:
  Copy

  X-Data-Source: test
  

• Or append a URL parameter:
  Copy

  ?x-data-source=test
  

• This allows your test frontend to interact with test data while your production frontend uses live data

​

4. Load Testing (External Tools Required)

​

The Mental Model: Why This Flow Works

​

The Pyramid of Confidence

        🚀 Production
       /            \
      /   Load Test   \     ← External validation
     /                  \
    /   Dry-Run (Test)   \  ← Real-world simulation
   /                      \
  /  Workflow Tests (Flow) \ ← Multi-step validation
 /                          \
/    Unit Tests (Function)   \ ← Foundational validation
--------------------------------
   Performance Insights       ← Baseline understanding

1. Performance Insights give you a baseline understanding of how things currently perform
2. Unit Tests validate individual components work correctly in isolation
3. Workflow Tests validate that components work together in realistic flows
4. Dry-Running with Test Data simulates real-world usage without risk
5. Load Testing validates your backend can handle production-level traffic
6. Production Deployment happens with confidence, knowing you’ve validated every layer

​

Why This Order?

• Bottom-up confidence: Fix individual issues before testing complex flows
• Iterative refinement: Each layer reveals different types of issues
• Risk mitigation: Catch problems early when they’re cheaper to fix
• Data safety: Test data isolation prevents production data corruption
• Performance planning: Load testing informs infrastructure decisions before you need to scale

​

Integration with CI/CD

• Dev: Build features, create unit tests
• Stage: Run workflow tests, dry-run with test data
• Pre-Production: Load test, review performance insights
• Production: Deploy with confidence

​

Deployment Readiness Checklist

• Reviewed Performance Insights for the past 7-30 days
• Identified and optimized slow-running queries and functions
• Created Unit Tests for all critical API endpoints
• Built Workflow Tests for key user flows
• Achieved 100% test coverage for critical paths
• Achieved 100% test success rate (or documented acceptable failures)
• Created and populated a Test Data Source
• Dry-run your application using test data
• Performed load testing with external tools (optional but recommended)
• Reviewed Request History for errors and anomalies
• Verified that your Scale plan can handle expected traffic
• Set up proper branching strategy for ongoing deployments
• Reviewed OpenAPI documentation to ensure endpoints are clearly documented

​

Next Steps

1. Publish your changes: Ensure all drafted work is published to your live environment
2. Review your branching strategy: See Branching & Merging
3. Connect your frontend: Follow the Connecting to a Frontend guide
4. Set up monitoring: Use Request History and Performance Insights to monitor production performance
5. Plan for scale: Review Adjust Server Performance if you anticipate growth

💡 Pro Tip: Deployment readiness isn’t a one-time checklist—it’s an ongoing practice. As you add new features, repeat these steps to maintain confidence in your backend’s stability.