Enterprise Onboarding

This guide outlines the complete onboarding process for enterprise Gastro deployments. Designed for multi-location operations, corporate caterers, and institutional food service with existing ERP or POS systems.

Onboarding Timeline

Typical enterprise onboarding takes 2-3 weeks from kick-off to launch:

Week 1          Week 2          Week 3
├─────────────┼─────────────┼─────────────┤
Kick-off      Integration   Training      Launch
│             │             │             │
├─ Planning   ├─ Technical  ├─ Chef       ├─ Go-Live
├─ Discovery  ├─ Data Map   ├─ Management ├─ Monitoring
└─ Setup      └─ Testing    └─ Support    └─ Optimization

Phase 1: Kick-off and Planning (Week 1)

Kick-off Workshop

Duration: 2-3 hours

Attendees:

• Executive sponsor (decision maker)
• Kitchen manager or head chef
• IT technical contact
• Marketing/communications lead
• Eaternity customer success manager

Agenda:

1. Project Goals (30 minutes)

   • Define success metrics (e.g., "20% emission reduction in 6 months")
   • Set KPI targets and reporting cadence
   • Align stakeholder expectations

2. Technical Discovery (60 minutes)

   • Review current systems (ERP, POS, recipe management)
   • Identify data sources and formats
   • Discuss integration architecture
   • Assess data quality and completeness

3. Operational Planning (45 minutes)

   • Map kitchen workflows
   • Identify change management needs
   • Plan chef training sessions
   • Define guest communication strategy

4. Project Timeline (15 minutes)

   • Confirm milestones and deadlines
   • Assign responsibilities
   • Schedule follow-up sessions

Deliverables:

• Project charter with goals and KPIs
• Technical integration plan
• Training and communication timeline

Discovery and Assessment

Following the kick-off, the Eaternity team conducts:

System Audit:

• Document existing software (versions, configurations)
• Review data exports and API documentation
• Assess data quality (completeness, accuracy, formatting)
• Identify integration points and dependencies

Recipe Database Review:

• Export sample recipe data
• Analyze ingredient naming conventions
• Identify problematic or ambiguous entries
• Estimate effort for SKU mapping

Stakeholder Interviews:

• Chefs: Menu planning workflows, seasonality patterns
• Procurement: Supplier data, origin information
• IT: Infrastructure, security, support model
• Communications: Brand guidelines, sustainability messaging

Risk Assessment:

• Technical risks (API compatibility, data volume)
• Operational risks (staff resistance, workflow changes)
• Data risks (missing information, quality issues)
• Mitigation strategies for each

Account Setup

While discovery proceeds, Eaternity provisions:

• Production environment - Your organization's Gastro instance
• API credentials - Production and staging access keys
• User accounts - Admin, chef, and read-only access levels
• Slack channel - Dedicated support and communication
• Document repository - Shared workspace for project artifacts

Phase 2: Technical Integration (Week 2)

Integration Architecture

Choose the architecture that fits your needs:

Option 1: Software Partner Integration

If you use supported systems (SAP, Delegate, Matilda):

Your ERP/POS → Partner Connector → Gastro API → Results DB
                                              ↓
                                     Reports + Menu Labels

Benefits:

• Pre-built, tested integration
• 1-2 week implementation
• Ongoing support from software partner

Option 2: Custom API Integration

For proprietary or unsupported systems:

Your System → Custom Middleware → Gastro API → Your System
                                              ↓
                                     Display Results

Benefits:

• Full control over data flow
• Flexible implementation
• Direct integration with internal tools

Option 3: Hybrid Approach

Combine automated and manual processes:

High-volume recipes → API → Automatic scoring
Special/seasonal items → Web App → Manual entry

Benefits:

• Best of both worlds
• Lower initial investment
• Gradual scaling

Data Mapping

Map your product database to Gastro ingredients:

Step 1: Export Your Data

Extract from your system:

• Product SKUs or IDs
• Product names/descriptions
• Current recipe formulations
• Unit of measure
• (Optional) Supplier, origin, organic certification

Example CSV export:

SKU,Product_Name,Category,UOM
10234,Rinderhackfleisch Bio,Fleisch,kg
10567,Spaghetti Nr. 5 Barilla,Pasta,kg
20891,Tomaten Pelati Bio,Gemüse,kg

Step 2: Ingredient Matching

Eaternity team performs initial matching:

1. Automated matching - Algorithm matches ~60-70% of items
2. Manual review - Expert review of ambiguous cases
3. Customer validation - Your team confirms matches
4. Gap identification - Flag missing database entries

Matching challenges and solutions:

Challenge	Example	Solution
Brand-specific products	"Barilla Spaghetti #5"	Map to generic "Pasta, wheat, dried"
Prepared products	"Curry sauce ready-made"	Decompose to base ingredients
Regional names	"Zucchetti" (Swiss) vs "Zucchini"	Use synonym mapping
Quality grades	"USDA Prime Beef"	Map to standard "Beef" + modifier

Step 3: Create Mapping Table

Build a lookup table for automated conversion:

{
  "sku_mappings": [
    {
      "sku": "10234",
      "product_name": "Rinderhackfleisch Bio",
      "eaternity_ingredient_id": "ing_beef_ground_organic_ch",
      "default_origin": "Switzerland",
      "organic": true,
      "unit_conversion": {
        "from": "kg",
        "to": "g",
        "factor": 1000
      }
    },
    {
      "sku": "10567",
      "product_name": "Spaghetti Nr. 5 Barilla",
      "eaternity_ingredient_id": "ing_pasta_wheat_dried",
      "default_origin": "Italy",
      "organic": false,
      "unit_conversion": {
        "from": "kg",
        "to": "g",
        "factor": 1000
      }
    }
  ]
}

Learn more about SKU mapping →

Integration Development

Week 2, Days 1-3: Development

Eaternity or your development team builds the integration:

1. Authentication - Implement API key management
2. Data extraction - Pull recipes from your system
3. Transformation - Convert to Gastro API format using mapping table
4. API calls - Send recipes for scoring (batch processing)
5. Response handling - Parse results and store scores
6. Error handling - Retry logic, logging, alerts

Sample integration code (Python):

import requests
import logging

class GastroIntegration:
    def __init__(self, api_key, mapping_table):
        self.api_key = api_key
        self.base_url = "https://api.eaternity.org/v1"
        self.mapping = mapping_table

    def fetch_recipes_from_erp(self):
        """
        Fetch recipes from your ERP system.
        Implementation depends on your specific system.
        """
        # Your ERP API call here
        recipes = erp_client.get_active_recipes()
        return recipes

    def transform_recipe(self, erp_recipe):
        """
        Transform ERP recipe format to Gastro API format.
        """
        ingredients = []
        for item in erp_recipe['items']:
            # Look up in mapping table
            mapping = self.mapping.get(item['sku'])
            if mapping:
                ingredients.append({
                    'name': mapping['eaternity_ingredient_id'],
                    'quantity': item['quantity'] * mapping['unit_conversion']['factor'],
                    'unit': mapping['unit_conversion']['to'],
                    'origin': mapping.get('default_origin'),
                    'organic': mapping.get('organic', False)
                })
            else:
                logging.warning(f"No mapping for SKU {item['sku']}")

        return {
            'name': erp_recipe['name'],
            'servings': erp_recipe['servings'],
            'ingredients': ingredients
        }

    def score_recipe(self, recipe):
        """
        Send recipe to Gastro API for scoring.
        """
        url = f"{self.base_url}/recipes/score"
        headers = {
            'Authorization': f'Bearer {self.api_key}',
            'Content-Type': 'application/json'
        }

        response = requests.post(url, headers=headers, json={'recipe': recipe})
        response.raise_for_status()
        return response.json()

    def process_all_recipes(self):
        """
        Main integration workflow.
        """
        recipes = self.fetch_recipes_from_erp()
        results = []

        for erp_recipe in recipes:
            try:
                gastro_recipe = self.transform_recipe(erp_recipe)
                score = self.score_recipe(gastro_recipe)
                results.append({
                    'recipe_id': erp_recipe['id'],
                    'scores': score
                })
                # Update ERP with scores
                erp_client.update_recipe_scores(erp_recipe['id'], score)

            except Exception as e:
                logging.error(f"Error processing {erp_recipe['name']}: {e}")

        return results

Week 2, Days 4-5: Testing

Comprehensive testing phase:

1. Unit tests - Individual functions and transformations
2. Integration tests - End-to-end data flow
3. Performance tests - Batch processing speed and throughput
4. Edge case testing - Missing data, errors, unusual recipes

Test checklist:

• Authentication works in staging and production
• Recipe transformation handles all SKU types
• Batch processing completes within expected time
• Error handling logs and retries appropriately
• Results stored correctly in your system
• No data loss or corruption during transfer

Integration Validation

Before go-live, validate with real data:

Sample Validation (50 recipes):

1. Select 50 diverse recipes (appetizers, mains, desserts, beverages)
2. Process through integration
3. Review scores for accuracy and consistency
4. Chef team validates ingredient matching
5. Iterate on mapping table as needed

Acceptance criteria:

• ✅ 95%+ ingredient matching accuracy
• ✅ Scores calculate in < 5 seconds per recipe
• ✅ Zero critical errors in test runs
• ✅ Chef team approves results

Phase 3: Training and Enablement (Week 3)

Chef Training Workshop

Duration: Half-day (4 hours)

Attendees: Kitchen managers, head chefs, menu planners

Session 1: Understanding Scores (90 minutes)

1. Scoring Basics (30 min)

   • What do climate scores measure?
   • How are ratings calculated (A-E scale)?
   • What is "cradle-to-kitchen" boundary?

2. Hands-On Scoring (45 min)

   • Log into Gastro app
   • Score 3-5 recipes from your menu
   • Interpret results and breakdowns
   • Compare recipe variants

3. Q&A and Discussion (15 min)

   • Address concerns and questions
   • Clarify methodology

Session 2: Chef Playbook (90 minutes)

1. Impact Reduction Strategies (45 min)

   • Plant-forward protein swaps
   • Seasonal produce sourcing
   • Origin and transport optimization
   • Certified ingredients (organic, regenerative)

2. Recipe Optimization Exercise (45 min)

   • Select 3 high-impact dishes from your menu
   • Apply playbook strategies
   • Calculate new scores
   • Discuss feasibility and guest acceptance

View complete Chef Playbook →

Break (30 minutes)

Session 3: Workflow Integration (60 minutes)

1. Menu Planning with Gastro (30 min)

   • How to check scores during planning
   • Setting climate targets for menus
   • Balancing impact across meal periods

2. Communication and Marketing (30 min)

   • Using Eaternity Award for promotion
   • Menu label design and placement
   • QR codes for detailed impact info
   • Social media and campaign ideas

Deliverables:

• Trained chef team confident using Gastro
• 3 optimized recipes ready for testing
• Action plan for menu rollout

Management Training

Duration: 90 minutes

Attendees: Operations managers, sustainability leads, executives

Topics:

1. KPI Tracking (30 min)

   • Reading monthly reports
   • Understanding trend analysis
   • Peer benchmarking interpretation
   • Setting improvement targets

2. Eaternity Award (20 min)

   • Criteria for 5/5 certification (top 20%)
   • Award assets and marketing materials
   • Guest communication strategies
   • Case studies from other organizations

3. Reporting and Governance (40 min)

   • Automated monthly report generation
   • Custom report creation for stakeholders
   • Integrating into sustainability KPIs
   • Board-level reporting templates

IT/Support Training

Duration: 2 hours

Attendees: IT team, system administrators

Topics:

1. System Architecture (30 min)

   • Integration overview and data flows
   • Monitoring and logging
   • Error handling and alerts

2. Troubleshooting (45 min)

   • Common issues and resolutions
   • Support escalation procedures
   • Accessing Eaternity support via Slack
   • Maintenance windows and updates

3. Advanced Features (45 min)

   • API rate limits and optimization
   • Webhook configuration for updates
   • Custom report generation
   • Data export and analytics

Phase 4: Launch and Rollout (Week 3-4)

Soft Launch

Start with limited rollout:

Pilot Location/Menu:

1. Select 1-2 pilot kitchens or meal periods
2. Activate climate-friendly menu labeling
3. Train service staff on guest communication
4. Monitor guest feedback and questions

Metrics to Track:

• Dish selection rates (climate-friendly vs high-impact)
• Guest questions and feedback
• Kitchen workflow impacts
• Technical system performance

Duration: 1-2 weeks

Full Launch

Roll out to all locations:

Launch Checklist:

• All recipes scored and ratings assigned
• Integration running smoothly (daily monitoring)
• Kitchen teams trained and confident
• Menu labels designed and printed
• QR codes generated and tested
• Marketing campaign prepared
• PR announcement (if applicable)
• Internal communications sent

Launch Day Activities:

1. Technical: Monitor integration for errors/issues
2. Operations: Kitchen managers check recipe scores display
3. Communications: Social media and PR go live
4. Support: Extra support coverage for questions

Post-Launch Support

Week 1 After Launch:

• Daily check-ins with kitchen teams
• Monitor technical performance metrics
• Address issues within 4-hour SLA
• Collect feedback and suggestions

Month 1 After Launch:

• Weekly review calls
• First monthly report generation and review
• Identify optimization opportunities
• Plan next phase improvements

Ongoing:

• Monthly report review calls
• Quarterly business reviews
• Continuous optimization support
• Database updates and recalculations

Pricing

For current pricing information, see the Pricing page.

Success Metrics

Track these KPIs to measure program success:

Operational Metrics

Recipe Coverage:

• Target: 100% of active menu items scored within 1 month
• Measure: Number of scored recipes / Total active recipes

Data Quality:

• Target: 95%+ ingredient matching accuracy
• Measure: Correctly matched ingredients / Total ingredients

System Uptime:

• Target: 99.5% API availability
• Measure: Successful API calls / Total API calls

Environmental Metrics

Average Climate Score:

• Target: 10% reduction in first 6 months, 20% in 12 months
• Measure: Month-over-month average CO₂eq per dish

Climate-Friendly Dish Percentage:

• Target: 30% of menu achieves E rating (top 20%)
• Measure: E-rated dishes / Total dishes

Eaternity Award Certifications:

• Target: 10+ dishes certified in first 3 months
• Measure: Number of 5/5 awarded dishes

Business Metrics

Guest Selection Rate:

• Target: 20-30% increase in climate-friendly dish orders
• Measure: Orders of E-rated dishes before/after labeling

Marketing Impact:

• Target: 5% increase in sustainability-motivated guests
• Measure: Guest surveys, social media engagement

Cost Neutrality:

• Target: No increase in food cost percentage
• Measure: Food cost % before/after optimization

Common Challenges and Solutions

Challenge 1: Ingredient Matching Accuracy

Symptom: Many ingredients not recognized or mismatched

Root causes:

• Brand-specific product names
• Regional language variations
• Prepared/convenience products
• Unusual specialty ingredients

Solutions:

1. Create detailed mapping table with SKU → ingredient ID
2. Work with Eaternity to add missing ingredients (48h for Enterprise)
3. Use generic terms instead of brand names
4. Decompose convenience products into base ingredients

Challenge 2: Staff Resistance

Symptom: Chefs reluctant to use system or change recipes

Root causes:

• Fear of menu constraints
• Lack of understanding of methodology
• Concern about guest acceptance
• Additional workload perception

Solutions:

1. Frame as empowerment tool, not constraint
2. Involve chefs early in kick-off and planning
3. Showcase quick wins from simple swaps
4. Celebrate successes with Eaternity Award
5. Provide chef training emphasizing flavor and guest satisfaction

Challenge 3: Data Quality Issues

Symptom: Inaccurate scores due to missing/incorrect data

Root causes:

• Incomplete recipe formulations
• Missing origin information
• Outdated recipes in database
• Incorrect units or quantities

Solutions:

1. Audit recipe database before integration
2. Standardize recipe formats and requirements
3. Regular data quality checks (monthly reviews)
4. Flag and fix issues in Gastro app

Challenge 4: Integration Technical Issues

Symptom: API errors, slow performance, data sync failures

Root causes:

• Rate limit exceeded
• Large batch sizes
• Network connectivity
• Authentication errors

Solutions:

1. Implement proper batching (50-100 recipes max)
2. Add retry logic with exponential backoff
3. Monitor rate limits in response headers
4. Use staging environment for testing
5. Contact Eaternity support for optimization

Next Steps After Onboarding

Month 2-3: Optimization Phase

Focus areas:

1. Recipe optimization - Systematically reduce high-impact dishes
2. Seasonal menu planning - Leverage seasonality for lower scores
3. Supplier collaboration - Work with procurement on origin data
4. Guest engagement - Launch marketing campaigns

Month 4-6: Scaling Phase

Focus areas:

1. Additional locations - Roll out to all kitchens
2. Advanced features - Custom calculation rules, supplier-specific data
3. Reporting automation - BI tool integration
4. Award maximization - Get more dishes to E rating

Month 7-12: Maturity Phase

Focus areas:

1. Continuous improvement - Track trends and set new targets
2. Innovation - Test new low-impact recipes and ingredients
3. Thought leadership - Share success stories publicly
4. Advocacy - Influence supplier and industry practices

Support Resources

Dedicated Slack Channel

Enterprise customers receive:

• Direct access to Eaternity support engineers
• 4-hour response SLA during business hours
• Proactive alerts on system issues
• Database update notifications

Quarterly Business Reviews

Review calls every 3 months:

• Performance against KPIs
• Menu optimization opportunities
• Feature roadmap and upcoming releases
• Best practice sharing

Knowledge Base

Access to:

• Complete documentation (this site)
• Video tutorials and webinars
• Case studies from similar organizations
• Integration code examples

Professional Services

On-demand support for:

• Recipe optimization consulting
• Marketing campaign development
• Custom feature development
• Additional training sessions

Frequently Asked Questions

How long until we see results?

Most organizations see measurable impact within 1-2 months:

• Immediate: Baseline scores and identification of high-impact dishes
• Week 4: First optimized recipes launched
• Month 2: 10-15% average emission reduction
• Month 6: 20-25% reduction with systematic optimization

Can we customize the integration?

Yes - Enterprise customers can:

• Add custom calculation rules for specific suppliers
• Create organization-specific reporting templates
• Integrate with BI tools (Tableau, Power BI, etc.)
• Develop custom workflows in the web app

What if our ERP/POS is not a listed partner?

Two options:

1. Custom API integration - Build using our REST API (contact sales for pricing)
2. Manual CSV workflow - Export from your system, import to Gastro

Most modern systems can be integrated via custom API development.

How do we handle recipe changes?

The integration automatically recalculates when recipes change. Historical scores are preserved for trend analysis.

Can we get supplier-specific data?

Yes - Enterprise customers can:

1. Upload supplier LCA reports (if available)
2. Work with Eaternity to create supplier-specific calculation rules
3. Use origin overrides for known sourcing patterns

What training is included?

Standard onboarding includes:

• Half-day chef workshop
• 90-minute management training
• 2-hour IT/support training

Additional training available as professional services.

How do we handle missing ingredients?

Enterprise support adds missing ingredients within 48 hours. Provide:

• Ingredient name and description
• Typical origin and production method
• Any available LCA data or product specs

Related Documentation

• API Quick Start - Developer integration guide
• SKU Mapping - Best practices for mapping
• Software Partners - Pre-built integrations
• Monthly Reports - KPI tracking and reporting
• Chef Playbook - Recipe optimization strategies