Deployment Guide

Master the art of publishing your Buzzy application to production. Learn the complete deployment checklist, Buzzy's managed hosting, and app store publishing.

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:

Pre-Publishing Checklist

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

🧪 Testing (Critical - Don't Skip):

🔒 Security (Absolutely Critical):

💾 Data Quality:

✍️ Content Polish:

⚖️ Legal & Compliance:

📊 Monitoring & Analytics (Optional but Recommended):

🚀 Launch Preparation:

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 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 for details

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.

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

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

Buzzy Advantage: No SSL certificate management needed. Buzzy handles provisioning, configuration, and renewal automatically for both Buzzy subdomains and custom domains.

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

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

Buzzy Advantage: Rollback is simple using the Versions tab. No complex deployment scripts or database migrations to manage.

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

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.

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]

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

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.

PreviousTesting ApproachesNextMaintenance & Tech Debt

Last updated