# Deployment Guide

## Before You Publish

Publishing in Buzzy isn't just clicking a button—it's ensuring your app is truly ready for real users.

**Non-technical explanation**: Deploying your app is like opening a restaurant. You wouldn't just unlock the doors without first ensuring the kitchen works, the staff is trained, the menu is finalized, and health inspections pass. Similarly, your Buzzy app needs thorough verification before going live.

**Why the pre-publish checklist matters**:

{% @mermaid/diagram content="%%{init: {'theme':'default', 'themeVariables': {'fontSize':'16px'}}}%%
graph TD
A\[Skip Checklist] --> B\[Publish Hastily]
B --> C\[Users Find Issues]
C --> D\[Emergency Fixes]
D --> E\[Lost Trust]

```
F[Follow Checklist] --> G[Publish Confidently]
G --> H[Smooth Launch]
H --> I[Happy Users]

style A fill:#f88,stroke:#333,color:#000
style E fill:#f88,stroke:#333,color:#000
style F fill:#6c6,stroke:#333,color:#000
style I fill:#6c6,stroke:#333,color:#000" %}
```

### Pre-Publishing Checklist

Use this comprehensive checklist to ensure your Buzzy app is truly ready for production:

**🧪 Testing (Critical - Don't Skip)**:

* [ ] **Critical paths tested thoroughly**: Main user journeys work end-to-end in preview mode
* [ ] **Edge cases handled**: Empty states, maximum values, invalid inputs all tested
* [ ] **Mobile tested**: Responsive layout works on phones and tablets
* [ ] **Desktop tested**: Full functionality on various screen sizes and browsers
* [ ] **All user roles tested**: Admin, editor, viewer—each role sees correct features
* [ ] **Performance verified**: App loads quickly, no lag when interacting
* [ ] **Live mode tested**: Beyond preview, actually publish to test environment first

**🔒 Security (Absolutely Critical)**:

* [ ] **No credentials exposed**: Double-check Buzzy Functions don't have hardcoded API keys or passwords
* [ ] **Constants properly used**: All secrets stored in encrypted Buzzy Constants, accessed via BUZZYCONSTANTS()
* [ ] **Authentication works**: Login, logout, password reset all functional
* [ ] **Viewers fields configured**: Server-level security in place for sensitive Datatables
* [ ] **Team Viewers set up**: If using Organizations/Teams, permissions configured correctly
* [ ] **Field validation works**: Required fields enforced, data types validated
* [ ] **Display rules tested**: Users only see what they should see based on role/ownership
* [ ] **Permission boundaries checked**: Users can't access unauthorized data or actions

**💾 Data Quality**:

* [ ] **Production data ready**: Real data loaded (not Lorem ipsum placeholders)
* [ ] **Test data removed**: All dummy records deleted from Datatables
* [ ] **Data relationships verified**: Subtables and Linked Table Fields work correctly
* [ ] **Backup created**: Important data exported/backed up before going live
* [ ] **Data migration tested**: If importing data, test the import process thoroughly

**✍️ Content Polish**:

* [ ] **Placeholder content replaced**: No "Your text here" or "Lorem ipsum" remaining
* [ ] **Images optimized**: Photos compressed for web, appropriate file sizes
* [ ] **Text proofread**: No typos, grammar checked, messaging clear
* [ ] **Branding consistent**: Logo, colors, fonts match your brand identity
* [ ] **Error messages clear**: User-friendly error messages, not technical jargon
* [ ] **Help text added**: Tooltips and instructions where users might need guidance

**⚖️ Legal & Compliance**:

* [ ] **Terms of Service**: Legal terms page created and linked
* [ ] **Privacy Policy**: Privacy policy written and accessible
* [ ] **Cookie consent**: Cookie banner if collecting analytics or using cookies
* [ ] **GDPR compliance**: If applicable, data handling follows regulations
* [ ] **Age restrictions**: If needed, age gate or parental consent flows
* [ ] **Accessibility**: Basic accessibility standards met (alt text, keyboard navigation)

**📊 Monitoring & Analytics** (Optional but Recommended):

* [ ] **Analytics configured**: If using Google Analytics or similar, tracking code added
* [ ] **Error logging**: Plan for capturing and reviewing errors
* [ ] **User feedback mechanism**: Way for users to report issues or provide feedback
* [ ] **Performance monitoring**: Basic tracking of app load times and responsiveness

**🚀 Launch Preparation**:

* [ ] **Launch plan documented**: Know exactly what happens at go-live
* [ ] **Support plan ready**: Who handles user questions? How?
* [ ] **Rollback plan**: Know how to quickly revert if major issues discovered
* [ ] **Announcement ready**: Communications prepared for users/customers
* [ ] **Documentation available**: User guides or help content accessible

**Verification timeline recommendation**:

```
3 days before launch:
- Complete functional testing
- Verify security and permissions
- Remove test data, add production data

2 days before launch:
- Content polish and proofreading
- Legal pages in place
- Performance testing

1 day before launch:
- Final end-to-end testing
- Verify all checklist items
- Sleep well!

Launch day:
- Publish during low-traffic hours
- Monitor closely for first few hours
- Be ready to respond to issues
```

## Publishing Options for Buzzy Apps

### Buzzy Managed Hosting (Recommended)

**What it is**: Publish directly through Buzzy platform

**Advantages**:

* Simplest option - no server management
* Automatic scaling on Kubernetes infrastructure
* Built-in SSL/HTTPS
* CDN included
* Buzzy Core Engine updates handled automatically
* No dependency management or framework upgrades
* Professional-grade infrastructure

**Steps**:

1. **Open your app in Buzzy Workspace**
2. **Go to Publish tab**
3. **Choose publishing plan**:
   * Free tier (for testing)
   * Professional (for production)
   * Enterprise (for custom needs)
4. **Configure domain** (optional):
   * Use Buzzy subdomain (app-name.buzzy.app)
   * Or connect custom domain
5. **Click "Publish"**
6. **Test the live URL**

**See**: [Buzzy Deployment & App Stores](https://docs.buzzy.buzz/working-with-buzzy/buzzy-deployment-and-app-stores) for detailed instructions

### Custom Server Deployment

**What it is**: Host on your own infrastructure

**When to use**:

* Specific compliance requirements
* Existing infrastructure mandates
* Custom networking needs

**See**: [Connecting your own server](https://docs.buzzy.buzz/working-with-buzzy/buzzy-deployment-and-app-stores/connecting-your-own-server) for details

{% hint style="info" %}
**Note**: With Buzzy's managed hosting, you don't need to worry about server setup, SSL certificates, or infrastructure maintenance. Buzzy handles all of this automatically.
{% endhint %}

## Web Application Publishing

### Environment Management in Buzzy

**Separate environments**:

**Preview Mode**:

* Test your app before publishing
* Use test data in Datatables
* Verify all features work
* Check mobile and desktop views

**Live Mode** (after publishing):

* Real user traffic
* Production data
* Optimized performance
* Monitored by Buzzy infrastructure

**Buzzy Functions Configuration**:

```
Use Buzzy Constants for:
- API keys (encrypted at rest)
- Service credentials
- Configuration values
- Feature flags

NEVER hard-code in Buzzy Functions:
- API secrets
- Passwords
- Connection strings
- Encryption keys

Access via: BUZZYCONSTANTS('constant_name')
```

**See**: [Buzzy Functions and Constants](https://docs.buzzy.buzz/the-building-blocks/buzzy-functions-and-constants)

### DNS and Domain Setup

**If using custom domain**:

**1. Register domain**:

* Use registrar (Namecheap, Google Domains, etc.)
* Choose memorable name
* Consider SEO implications

**2. Configure DNS**:

* Follow Buzzy's domain connection instructions in Publish tab
* Set up www redirect if desired

**3. Wait for DNS propagation** (up to 48 hours)

**4. Verify**:

* Test that domain resolves
* Check both www and non-www
* Verify SSL certificate (automatic with Buzzy)

### SSL/HTTPS Setup

**Why essential**:

* Required for secure data transmission
* Builds user trust
* Required for modern web features
* Improves SEO

**For Buzzy hosting**: Automatic - SSL certificates are automatically provisioned and renewed

{% hint style="success" %}
**Buzzy Advantage**: No SSL certificate management needed. Buzzy handles provisioning, configuration, and renewal automatically for both Buzzy subdomains and custom domains.
{% endhint %}

## Mobile App Deployment

### Deploying to App Stores

**Requirements**:

* Apple Developer Account ($99/year) for iOS
* Google Play Console Account ($25 one-time) for Android
* App icon and screenshots
* App description
* Privacy policy

**Process overview**:

**1. Prepare assets**:

* App icon (various sizes)
* Screenshots for different devices
* Marketing graphics
* App description
* Keywords for search

**2. Build app**:

* Use Buzzy's mobile build service
* Or build native apps yourself

**3. Submit to stores**:

* Apple App Store (1-7 days review)
* Google Play Store (hours to days review)

**4. Wait for approval**

**5. Manage releases**:

* Staged rollout recommended
* Monitor for issues
* Update as needed

**See**: [Apple & Google App Stores](https://docs.buzzy.buzz/working-with-buzzy/buzzy-deployment-and-app-stores/apple-and-google-app-stores)

### App Store Guidelines

**Apple App Store requirements**:

* Functional and bug-free
* Complete information
* Appropriate content
* Privacy policy
* No placeholder content
* Follows Human Interface Guidelines

**Google Play Store requirements**:

* Functional core features
* Stable performance
* Appropriate content
* Privacy policy
* Proper permissions
* Follows Material Design (recommended)

**Common rejection reasons**:

* Crashes on launch
* Broken features
* Misleading description
* Missing privacy policy
* Inappropriate content
* Copyright violations

## Publishing Process

### Standard Publishing Workflow in Buzzy

**1. Final Pre-Publishing Testing**:

```
- Test all features in preview mode one final time
- Have someone else test
- Check mobile and desktop in preview
- Verify all Datatables and screens work
- Test different user roles
```

**2. Prepare for Publishing**:

```
- Save current version in Buzzy's Versions tab
- Document any important notes
- Have rollback plan ready (can restore previous version)
- Schedule publishing time (off-peak if possible)
- Notify stakeholders
```

**3. Publish**:

```
- Go to Publish tab in Buzzy Workspace
- Click "Publish" or update existing deployment
- Buzzy handles the deployment automatically
- Wait for confirmation
```

**4. Post-Publishing Verification**:

```
- Test critical paths on live URL
- Verify data integrity in Datatables
- Check performance
- Test from different devices/locations
- Verify custom domain works (if configured)
```

**5. Monitor and Respond**:

```
- Watch for user reports
- Monitor app behavior
- Check usage patterns
- Use Buzzy's Versions tab to rollback if needed
```

### Publishing Timing

**Best times to publish**:

* Off-peak hours (when fewer users active)
* Early in week (Monday/Tuesday)
* When team available for monitoring
* Not right before weekends/holidays

**Worst times to publish**:

* Friday afternoon (no monitoring over weekend)
* Peak usage times
* Right before vacation
* During major events

## Rollback Planning

**Always have a rollback plan**:

**Before publishing**:

* Save current version in Buzzy's Versions tab
* Document version notes
* Know how to restore previous version
* Have communication plan

**If something goes wrong**:

1. Assess severity
2. Decide: Fix forward or rollback?
3. Use Buzzy's Versions tab to restore previous version if needed
4. Notify users if affected
5. Investigate and fix root cause
6. Publish again when ready

**See**: [Rollback Strategies](https://docs.buzzy.buzz/the-ultimate-guide-for-vibe-coding-an-application-with-ai/project-workflow/rollback-strategies)

{% hint style="success" %}
**Buzzy Advantage**: Rollback is simple using the Versions tab. No complex deployment scripts or database migrations to manage.
{% endhint %}

## Post-Publishing

### Monitoring Your Buzzy App

**Essential monitoring**:

**App Health**:

* Buzzy infrastructure handles uptime automatically
* Monitor user reports for issues
* Track app usage patterns

**User Experience**:

* Collect feedback through in-app forms
* Monitor user behavior
* Track feature usage

**Data Integrity**:

* Periodically review Datatables for anomalies
* Ensure data relationships working correctly
* Check for unexpected data patterns

**Usage Analytics**:

* Active users
* Popular features
* Conversion rates
* User flows

**Tools you can integrate**:

* Google Analytics (usage tracking)
* Custom analytics via Buzzy Functions
* Third-party feedback tools
* User behavior analytics

{% hint style="info" %}
**Note**: Buzzy's managed infrastructure handles uptime, performance, and error monitoring at the platform level. You can focus on monitoring user experience and app usage.
{% endhint %}

### User Communication

**Launch announcement**:

* Email users (if you have list)
* Social media announcement
* Blog post
* Show in-app announcement

**Gather feedback**:

* Feedback form in app
* User surveys
* Monitor support requests
* Track feature requests

**Stay responsive**:

* Respond to user issues quickly
* Fix critical bugs immediately
* Communicate about known issues
* Thank users for feedback

## Common Publishing Issues

### Issue: Custom Domain Not Working

**Symptoms**: Domain doesn't resolve to app, SSL errors

**Solution**:

* Verify DNS records configured correctly in Publish tab
* Wait for DNS propagation (up to 48 hours)
* Check domain registrar settings
* Contact Buzzy support if persisting

### Issue: Data Not Showing Correctly

**Symptoms**: Missing data, incorrect relationships

**Solution**:

* Verify data exists in Datatables (Data tab)
* Check Subtable and Linked Field relationships
* Verify display rules and filters in screens
* Check Viewers field permissions

### Issue: Buzzy Functions Not Working

**Symptoms**: Features using Functions fail, timeouts

**Solution**:

* Check Function code for errors
* Verify Constants are configured correctly
* Test Function locally if possible
* Review Function logs for errors
* Check API rate limits for external services

### Issue: Mobile Layout Issues

**Symptoms**: App doesn't display correctly on mobile

**Solution**:

* Test in preview mode on mobile device
* Adjust responsive layout settings in Design tab
* Simplify complex layouts for mobile
* Use Buzzy's mobile-friendly components

### Issue: Permission Problems

**Symptoms**: Users see or can't access features they shouldn't

**Solution**:

* Review Viewers and Team Viewers fields in Datatables
* Check display rules based on user roles
* Verify server-level security properly configured
* Test with different user accounts

## Publishing Checklist Template

```
Pre-Publishing:
- [ ] All features tested in preview mode
- [ ] Security configured (Viewers fields, display rules)
- [ ] Performance acceptable in live mode
- [ ] Buzzy Functions tested (if used)
- [ ] Constants configured (if needed)
- [ ] Version saved in Versions tab
- [ ] Rollback plan documented
- [ ] Team notified of publishing

Publishing:
- [ ] Publishing time scheduled
- [ ] Maintenance notice sent (if updating)
- [ ] Current version saved in Versions tab
- [ ] Publish via Publish tab
- [ ] Verify publishing successful
- [ ] SSL working (automatic with Buzzy)

Post-Publishing:
- [ ] Critical paths tested on live URL
- [ ] Data integrity verified in Datatables
- [ ] Users can access app
- [ ] Custom domain working (if configured)
- [ ] Team monitoring for issues
- [ ] Launch announcement sent

First 24 Hours:
- [ ] Monitor user feedback
- [ ] Check app behavior
- [ ] Review usage patterns
- [ ] Fix any critical issues
- [ ] Document lessons learned

Sign-off: [Date, Name]
```

## Multi-Environment Workflows

For professional development workflows, Buzzy supports Software Config Management (SCM) which allows you to maintain separate environments and push changes between them.

**Typical setup**:

**Development Environment**: Where you build and experiment with new features. Test thoroughly before promoting changes.

**Staging Environment**: A production-like environment for final testing and user acceptance. Catch issues before they reach real users.

**Production Environment**: Your live application serving real users. Only promote tested, approved changes here.

**How it works**:

1. Build and test features in your Development environment
2. Save a version when ready for promotion
3. Use the Publish panel to push the version to Staging
4. Perform final testing in Staging
5. Push the approved version to Production

**Benefits**:

* Safe experimentation without affecting production users
* Thorough testing before release
* Controlled release timing
* Easy rollback if issues discovered

**See**: [Software Config Management](https://docs.buzzy.buzz/working-with-buzzy/buzzy-deployment-and-app-stores/software-config-management) for detailed setup and usage instructions.

## Progressive Deployment

For larger apps or when cautious:

**Phase 1: Beta Launch** (1-2 weeks):

* Small group of users
* Gather feedback
* Fix issues
* Refine features

**Phase 2: Soft Launch** (1-2 weeks):

* Larger user group
* Monitor performance at scale
* Fix scaling issues
* Optimize based on real usage

**Phase 3: Full Launch**:

* All users
* Full marketing push
* Continuous monitoring
* Ongoing improvements

**Advantages**:

* Lower risk
* Real-world feedback early
* Can catch issues before full launch
* Builds anticipation

## Next Steps

* **Maintaining your app**: [Maintenance & Tech Debt](https://docs.buzzy.buzz/the-ultimate-guide-for-vibe-coding-an-application-with-ai/project-workflow/maintenance)
* **If something breaks**: [Rollback Strategies](https://docs.buzzy.buzz/the-ultimate-guide-for-vibe-coding-an-application-with-ai/project-workflow/rollback-strategies)
* **Planning ongoing development**: [Making Changes](https://docs.buzzy.buzz/the-ultimate-guide-for-vibe-coding-an-application-with-ai/project-workflow/making-changes)

{% hint style="success" %}
**Remember**: Publishing isn't the end—it's the beginning. Your app will need updates, fixes, and improvements. The good news: with Buzzy, the Core Engine maintenance is handled for you, so you can focus on improving your app's functionality and user experience.
{% endhint %}