Ship Mobile Apps to App Store and Play Store in One Week: Complete Expo + RevenueCat Guide

Shipping a mobile app to both the App Store and Play Store can feel overwhelming, especially when you need to integrate payments and subscriptions. But with Expo and RevenueCat, you can go from zero to live on both stores in less than a week.

This comprehensive guide will walk you through every step: setting up Expo, integrating RevenueCat for one-time payments and subscriptions, building production-ready apps, and navigating both store submission processes. By the end, you'll have a clear roadmap to get your app live in 7 days or less.

---

Why Expo + RevenueCat?

Expo eliminates the complexity of native iOS and Android development. You write React Native code once, and Expo handles the native build configuration, app signing, and deployment. No Xcode or Android Studio setup required.

RevenueCat simplifies in-app purchases and subscriptions. Instead of managing Apple's StoreKit and Google's Billing Library separately, RevenueCat provides a unified API that handles receipt validation, subscription status, and cross-platform user management.

Together, they let you:

• Build once, deploy to both platforms
• Handle payments without platform-specific code
• Get to market faster with less complexity
• Scale your subscription business with analytics and webhooks

---

Day 1: Project Setup and Foundation

Step 1: Initialize Your Expo Project

Start by creating a new Expo project with TypeScript:

npx create-expo-app@latest MyApp --template
# Select: blank (TypeScript)

cd MyApp

Install essential dependencies:

npx expo install expo-router react-native-safe-area-context react-native-screens
npm install @react-navigation/native

Step 2: Set Up Expo Application Services (EAS)

EAS is Expo's cloud service for building and submitting apps. Sign up and configure:

npm install -g eas-cli
eas login
eas build:configure

This creates an eas.json file. Configure it for both platforms:

{
  "cli": {
    "version": ">= 5.0.0"
  },
  "build": {
    "development": {
      "developmentClient": true,
      "distribution": "internal"
    },
    "preview": {
      "distribution": "internal",
      "ios": {
        "simulator": true
      }
    },
    "production": {
      "autoIncrement": true
    }
  },
  "submit": {
    "production": {}
  }
}

Step 3: Configure App Metadata

Update app.json with your app information:

{
  "expo": {
    "name": "Your App Name",
    "slug": "your-app-slug",
    "version": "1.0.0",
    "orientation": "portrait",
    "icon": "./assets/icon.png",
    "userInterfaceStyle": "light",
    "splash": {
      "image": "./assets/splash.png",
      "resizeMode": "contain",
      "backgroundColor": "#ffffff"
    },
    "ios": {
      "supportsTablet": true,
      "bundleIdentifier": "com.yourcompany.yourapp",
      "buildNumber": "1"
    },
    "android": {
      "adaptiveIcon": {
        "foregroundImage": "./assets/adaptive-icon.png",
        "backgroundColor": "#ffffff"
      },
      "package": "com.yourcompany.yourapp",
      "versionCode": 1
    },
    "plugins": [
      "expo-router"
    ]
  }
}

Critical: Your bundle identifier (iOS) and package name (Android) must be unique and match what you'll configure in App Store Connect and Google Play Console.

---

Day 2: RevenueCat Setup and Integration

Step 1: Create RevenueCat Account

1. Sign up at revenuecat.com
2. Create a new project
3. Note your Public API Key (you'll need this)

Step 2: Configure Products in RevenueCat Dashboard

In RevenueCat dashboard, create your products:

For One-Time Purchases:

• Product ID: premium_unlock
• Type: Non-Subscription
• Price: Set in App Store Connect / Play Console

For Subscriptions:

• Product ID: premium_monthly
• Type: Subscription
• Duration: 1 month
• Price: Set in App Store Connect / Play Console

Step 3: Install RevenueCat SDK

npm install react-native-purchases
npx expo install react-native-purchases

Step 4: Initialize RevenueCat in Your App

Create a RevenueCat service file:

// lib/revenuecat.ts
import Purchases, { 
  PurchasesOffering, 
  PurchasesPackage,
  CustomerInfo 
} from 'react-native-purchases';
import { Platform } from 'react-native';

const REVENUECAT_API_KEY = {
  ios: 'your_ios_api_key',
  android: 'your_android_api_key'
};

export class RevenueCatService {
  static async initialize(userId?: string) {
    const apiKey = Platform.OS === 'ios' 
      ? REVENUECAT_API_KEY.ios 
      : REVENUECAT_API_KEY.android;
    
    await Purchases.configure({ apiKey });
    
    if (userId) {
      await Purchases.logIn(userId);
    }
  }

  static async getOfferings(): Promise<PurchasesOffering | null> {
    try {
      const offerings = await Purchases.getOfferings();
      return offerings.current;
    } catch (error) {
      console.error('Error fetching offerings:', error);
      return null;
    }
  }

  static async purchasePackage(pkg: PurchasesPackage): Promise<CustomerInfo> {
    try {
      const { customerInfo } = await Purchases.purchasePackage(pkg);
      return customerInfo;
    } catch (error) {
      console.error('Purchase error:', error);
      throw error;
    }
  }

  static async restorePurchases(): Promise<CustomerInfo> {
    try {
      return await Purchases.restorePurchases();
    } catch (error) {
      console.error('Restore error:', error);
      throw error;
    }
  }

  static async getCustomerInfo(): Promise<CustomerInfo> {
    try {
      return await Purchases.getCustomerInfo();
    } catch (error) {
      console.error('Error fetching customer info:', error);
      throw error;
    }
  }

  static async checkSubscriptionStatus(): Promise<boolean> {
    try {
      const customerInfo = await this.getCustomerInfo();
      return customerInfo.entitlements.active['premium'] !== undefined;
    } catch (error) {
      return false;
    }
  }
}

Step 5: Create Payment UI Component

// components/Paywall.tsx
import React, { useEffect, useState } from 'react';
import { View, Text, Button, ActivityIndicator } from 'react-native';
import { RevenueCatService } from '@/lib/revenuecat';
import { PurchasesOffering, PurchasesPackage } from 'react-native-purchases';

export function Paywall() {
  const [offering, setOffering] = useState<PurchasesOffering | null>(null);
  const [loading, setLoading] = useState(true);
  const [purchasing, setPurchasing] = useState(false);

  useEffect(() => {
    loadOfferings();
  }, []);

  const loadOfferings = async () => {
    try {
      const currentOffering = await RevenueCatService.getOfferings();
      setOffering(currentOffering);
    } catch (error) {
      console.error('Error loading offerings:', error);
    } finally {
      setLoading(false);
    }
  };

  const handlePurchase = async (pkg: PurchasesPackage) => {
    setPurchasing(true);
    try {
      const customerInfo = await RevenueCatService.purchasePackage(pkg);
      
      if (customerInfo.entitlements.active['premium']) {
        // User now has premium access
        console.log('Purchase successful!');
        // Navigate to premium content or update UI
      }
    } catch (error: any) {
      if (error.userCancelled) {
        console.log('User cancelled purchase');
      } else {
        console.error('Purchase failed:', error);
      }
    } finally {
      setPurchasing(false);
    }
  };

  const handleRestore = async () => {
    try {
      await RevenueCatService.restorePurchases();
      // Check subscription status and update UI
    } catch (error) {
      console.error('Restore failed:', error);
    }
  };

  if (loading) {
    return <ActivityIndicator />;
  }

  if (!offering) {
    return <Text>No offerings available</Text>;
  }

  return (
    <View>
      <Text>Choose Your Plan</Text>
      
      {/* One-Time Purchase */}
      {offering.availablePackages.find(pkg => 
        pkg.identifier === '$rc_one_time_purchase'
      ) && (
        <View>
          <Text>Premium Unlock - One Time</Text>
          <Button
            title={`Buy for ${offering.availablePackages.find(pkg => 
              pkg.identifier === '$rc_one_time_purchase'
            )?.product.priceString}`}
            onPress={() => handlePurchase(
              offering.availablePackages.find(pkg => 
                pkg.identifier === '$rc_one_time_purchase'
              )!
            )}
            disabled={purchasing}
          />
        </View>
      )}

      {/* Monthly Subscription */}
      {offering.availablePackages.find(pkg => 
        pkg.identifier === 'monthly'
      ) && (
        <View>
          <Text>Premium Monthly</Text>
          <Button
            title={`Subscribe for ${offering.availablePackages.find(pkg => 
              pkg.identifier === 'monthly'
            )?.product.priceString}/month`}
            onPress={() => handlePurchase(
              offering.availablePackages.find(pkg => 
                pkg.identifier === 'monthly'
              )!
            )}
            disabled={purchasing}
          />
        </View>
      )}

      <Button title="Restore Purchases" onPress={handleRestore} />
    </View>
  );
}

Step 6: Initialize RevenueCat in App Entry Point

// app/_layout.tsx or App.tsx
import { useEffect } from 'react';
import { RevenueCatService } from '@/lib/revenuecat';

export default function RootLayout() {
  useEffect(() => {
    // Initialize RevenueCat when app starts
    RevenueCatService.initialize();
  }, []);

  // ... rest of your app
}

---

Day 3: App Store Connect Setup (iOS)

Step 1: Create Apple Developer Account

1. Go to developer.apple.com
2. Enroll in Apple Developer Program ($99/year)
3. Wait for approval (usually 24-48 hours, but can take longer)

Pro Tip: Start this process immediately, even before your app is ready. Approval can be the longest wait.

Step 2: Create App in App Store Connect

1. Go to appstoreconnect.apple.com
2. Click "My Apps" → "+" → "New App"
3. Fill in:
   • Platform: iOS
   • Name: Your App Name
   • Primary Language: English
   • Bundle ID: Must match your app.json bundleIdentifier
   • SKU: Unique identifier (e.g., yourapp-001)

Step 3: Configure In-App Purchases

1. In App Store Connect, go to your app → Features → In-App Purchases
2. Click "+" to create products

For One-Time Purchase:

• Type: Non-Consumable
• Product ID: premium_unlock (must match RevenueCat)
• Reference Name: Premium Unlock
• Price: Set your price

For Subscription:

• Type: Auto-Renewable Subscription
• Product ID: premium_monthly (must match RevenueCat)
• Subscription Group: Create new group (e.g., "Premium")
• Duration: 1 Month
• Price: Set your price
• Review Information: Provide screenshots and description

Critical: Product IDs must exactly match what you configured in RevenueCat.

Step 4: Link RevenueCat to App Store Connect

1. In RevenueCat dashboard → Project Settings → Integrations
2. Click "Connect" next to App Store Connect
3. Follow the OAuth flow to authorize RevenueCat
4. Select your app and sync products

Step 5: Prepare App Store Listing

While building, prepare:

• App screenshots (required sizes: 6.5", 6.7", 5.5")
• App preview video (optional but recommended)
• Description (up to 4,000 characters)
• Keywords (up to 100 characters)
• Support URL
• Privacy Policy URL (required for apps with purchases)
• Category selection
• Age rating questionnaire

---

Day 4: Google Play Console Setup (Android)

Step 1: Create Google Play Developer Account

1. Go to play.google.com/console
2. Pay one-time $25 registration fee
3. Account is usually approved within hours

Step 2: Create App in Google Play Console

1. Click "Create app"
2. Fill in:
   • App name
   • Default language
   • App or game
   • Free or paid
   • Declare if you collect user data

Step 3: Configure In-App Products

1. Go to Monetize → Products → In-app products
2. Create products:

For One-Time Purchase:

• Product ID: premium_unlock (must match RevenueCat)
• Name: Premium Unlock
• Description: What users get
• Price: Set your price
• Status: Active

For Subscription:

• Product ID: premium_monthly (must match RevenueCat)
• Name: Premium Monthly
• Description: Subscription benefits
• Billing period: 1 month
• Price: Set your price
• Free trial: Optional
• Grace period: Optional

Step 4: Link RevenueCat to Google Play

1. In RevenueCat dashboard → Project Settings → Integrations
2. Click "Connect" next to Google Play Console
3. Upload your service account JSON key:
   • In Google Play Console → Setup → API access
   • Create service account
   • Download JSON key
   • Upload to RevenueCat

Step 5: Prepare Play Store Listing

• App icon (512x512px)
• Feature graphic (1024x500px)
• Screenshots (at least 2, up to 8)
• Short description (80 characters)
• Full description (4,000 characters)
• Privacy Policy URL (required)
• Content rating questionnaire
• Target audience

---

Day 5: Building Production Apps

Step 1: Configure EAS Build

Update eas.json for production builds:

{
  "build": {
    "production": {
      "ios": {
        "bundleIdentifier": "com.yourcompany.yourapp"
      },
      "android": {
        "package": "com.yourcompany.yourapp"
      },
      "env": {
        "REVENUECAT_IOS_KEY": "your_ios_key",
        "REVENUECAT_ANDROID_KEY": "your_android_key"
      }
    }
  }
}

Step 2: Build iOS App

eas build --platform ios --profile production

This will:

1. Upload your code to EAS servers
2. Build your app in the cloud
3. Generate an .ipa file
4. Provide a download link

First build takes 15-20 minutes. Subsequent builds are faster.

Step 3: Build Android App

eas build --platform android --profile production

Generates an .aab (Android App Bundle) file, which is required for Play Store submission.

Step 4: Test Your Builds

Download and install the builds on physical devices:

iOS:

• Install via TestFlight (recommended) or direct install
• Test all payment flows
• Verify RevenueCat integration

Android:

• Install the .aab file (convert to APK for testing if needed)
• Test on multiple Android versions
• Verify payment flows

---

Day 6: App Store Submission (iOS)

Step 1: Submit Build via EAS

eas submit --platform ios --latest

EAS will:

1. Upload your build to App Store Connect
2. Process it (takes 10-30 minutes)
3. Make it available for submission

Step 2: Complete App Store Connect Listing

1. Go to App Store Connect → Your App
2. Fill in all required information:
   • App Information
   • Pricing and Availability
   • App Privacy (required)
   • App Store listing (screenshots, description, etc.)

Step 3: Submit for Review

1. In App Store Connect, go to the version you want to submit
2. Scroll to "Build" section
3. Select your uploaded build
4. Answer export compliance questions
5. Click "Submit for Review"

Review Time: Typically 24-48 hours, but can take up to 7 days.

Step 4: Common Rejection Reasons (How to Avoid)

• Missing Privacy Policy: Required for apps with in-app purchases
• Incomplete App Information: Fill all required fields
• Guideline Violations: Review App Store Review Guidelines
• Payment Issues: Ensure RevenueCat is properly configured
• Crash on Launch: Test thoroughly before submitting

---

Day 7: Play Store Submission (Android)

Step 1: Create Release

1. In Google Play Console → Your App → Production
2. Click "Create new release"
3. Upload your .aab file (from EAS build)
4. Add release name (e.g., "1.0.0 - Initial Release")
5. Add release notes

Step 2: Complete Store Listing

1. Go to Store presence → Main store listing
2. Upload all required assets
3. Fill in description, screenshots, etc.
4. Complete content rating questionnaire
5. Set up pricing (if paid app)

Step 3: Complete Required Sections

• App content: Age rating, content ratings
• Privacy policy: Required URL
• Data safety: Declare data collection practices
• Target audience: Set age groups

Step 4: Submit for Review

1. Go to Production → Review releases
2. Review all sections (green checkmarks)
3. Click "Start rollout to Production"
4. Confirm submission

Review Time: Usually 1-3 days, but can take up to 7 days for first submission.

---

Testing RevenueCat Integration

Before submitting, thoroughly test:

Test One-Time Purchases

// Test flow
1. Load paywall
2. Click "Buy Premium Unlock"
3. Complete purchase flow
4. Verify entitlement is active
5. Restore purchases (logout/login)
6. Verify entitlement persists

Test Subscriptions

// Test flow
1. Subscribe to monthly plan
2. Verify active subscription
3. Test subscription renewal (use sandbox)
4. Test cancellation flow
5. Test grace period (if configured)

Use Sandbox Testers

iOS:

• Create sandbox testers in App Store Connect
• Sign out of App Store on device
• Use sandbox account when prompted

Android:

• Add test accounts in Play Console
• Use test accounts to make purchases
• Purchases are free in sandbox

---

Common Pitfalls and Solutions

Pitfall 1: Product ID Mismatch

Problem: Product IDs don't match between RevenueCat, App Store Connect, and Google Play.

Solution:

• Use consistent naming: premium_unlock, premium_monthly
• Double-check all three places match exactly
• RevenueCat dashboard shows mismatched products

Pitfall 2: Missing Entitlements

Problem: App doesn't recognize user has premium access.

Solution:

// Always check entitlements, not just purchases
const customerInfo = await RevenueCatService.getCustomerInfo();
const isPremium = customerInfo.entitlements.active['premium'] !== undefined;

Pitfall 3: Build Configuration Errors

Problem: EAS build fails due to missing configuration.

Solution:

• Ensure app.json has correct bundle identifiers
• Check eas.json configuration
• Verify all environment variables are set

Pitfall 4: Store Review Rejections

Problem: App rejected for missing information.

Solution:

• Privacy policy is mandatory for apps with purchases
• Complete all required fields in store consoles
• Provide clear app descriptions
• Test app thoroughly before submission

Pitfall 5: RevenueCat Not Syncing

Problem: Products not appearing in app.

Solution:

• Verify RevenueCat integration is connected
• Check product IDs match exactly
• Ensure products are "Active" in store consoles
• Wait a few minutes after creating products (propagation delay)

---

Timeline Breakdown: One Week to Live

Day 1: Foundation

• ✅ Set up Expo project
• ✅ Configure EAS
• ✅ Basic app structure

Day 2: Payments

• ✅ RevenueCat account setup
• ✅ SDK integration
• ✅ Payment UI implementation
• ✅ Test purchases locally

Day 3: iOS Preparation

• ✅ Apple Developer account (start early!)
• ✅ App Store Connect setup
• ✅ In-app purchase configuration
• ✅ RevenueCat iOS integration

Day 4: Android Preparation

• ✅ Google Play Developer account
• ✅ Play Console setup
• ✅ In-app product configuration
• ✅ RevenueCat Android integration

Day 5: Building

• ✅ Production iOS build
• ✅ Production Android build
• ✅ Testing on devices
• ✅ Fix any issues

Day 6: iOS Submission

• ✅ Submit iOS build
• ✅ Complete App Store listing
• ✅ Submit for review

Day 7: Android Submission

• ✅ Upload Android build
• ✅ Complete Play Store listing
• ✅ Submit for review

After Submission:

• Monitor review status
• Respond to any review feedback
• Prepare for launch marketing

---

Best Practices for Success

1. Start Store Accounts Early

Apple Developer approval can take 24-48 hours. Start this process on Day 1, even before your app is ready.

2. Test Extensively

Use sandbox testers for both platforms. Test:

• Purchase flows
• Restore purchases
• Subscription renewals
• Edge cases (network errors, cancellations)

3. Prepare Assets in Advance

Create screenshots, descriptions, and marketing materials while your app is building. Don't wait until submission day.

4. Monitor RevenueCat Dashboard

Check the RevenueCat dashboard regularly for:

• Product sync status
• Purchase analytics
• Webhook events
• Error logs

5. Set Up Webhooks

Configure RevenueCat webhooks to your backend for:

• Subscription status updates
• Purchase notifications
• User management

6. Handle Edge Cases

// Example: Handle network errors gracefully
try {
  await RevenueCatService.purchasePackage(pkg);
} catch (error: any) {
  if (error.userCancelled) {
    // User cancelled - don't show error
  } else if (error.code === 'NETWORK_ERROR') {
    // Show retry option
  } else {
    // Show generic error message
  }
}

7. Implement Restore Purchases

Always provide a "Restore Purchases" button. Users expect this, especially when switching devices.

8. Use RevenueCat Entitlements

Don't check for specific product IDs. Check for entitlements instead:

// ❌ Bad: Checking product ID
const hasPremium = customerInfo.activeSubscriptions.includes('premium_monthly');

// ✅ Good: Checking entitlement
const hasPremium = customerInfo.entitlements.active['premium'] !== undefined;

This works for both subscriptions and one-time purchases.

---

RevenueCat Advanced Features

Offerings and Packages

RevenueCat's offerings system lets you create different paywall configurations:

// In RevenueCat dashboard, create offerings:
// - Default: Standard paywall
// - Promo: Special promotion
// - A/B Test: Different pricing

// In your app:
const offering = await RevenueCatService.getOfferings();
const monthlyPackage = offering?.availablePackages.find(
  pkg => pkg.identifier === 'monthly'
);

Promotional Offers

Offer discounts to specific users:

// In RevenueCat dashboard → Promotional Offers
// Create offers for:
// - Win-back campaigns
// - Special promotions
// - User segments

Webhooks Integration

Set up webhooks for server-side processing:

// RevenueCat sends webhooks for:
// - Initial purchase
// - Subscription renewal
// - Cancellation
// - Billing issues

// Example webhook handler (Node.js):
app.post('/webhooks/revenuecat', async (req, res) => {
  const event = req.body;
  
  if (event.type === 'INITIAL_PURCHASE') {
    // Grant premium access
    await grantPremiumAccess(event.app_user_id);
  }
  
  if (event.type === 'CANCELLATION') {
    // Handle cancellation
    await handleCancellation(event.app_user_id);
  }
  
  res.status(200).send('OK');
});

Analytics and Insights

RevenueCat provides built-in analytics:

• Revenue metrics
• Churn analysis
• Conversion rates
• User cohorts
• Product performance

Access these in the RevenueCat dashboard under "Charts" and "Customers".

---

Post-Launch Checklist

Once your app is live:

Week 1

• ✅ Monitor crash reports
• ✅ Check RevenueCat dashboard for purchases
• ✅ Respond to user reviews
• ✅ Fix any critical bugs
• ✅ Monitor App Store/Play Store analytics

Week 2-4

• ✅ Analyze user behavior
• ✅ Optimize paywall conversion
• ✅ A/B test pricing
• ✅ Implement user feedback
• ✅ Plan feature updates

Ongoing

• ✅ Regular app updates
• ✅ Monitor subscription metrics
• ✅ Optimize retention
• ✅ Expand to new markets
• ✅ Add new products/features

---

Troubleshooting Guide

Issue: "No offerings available"

Causes:

• Products not synced between stores and RevenueCat
• Products not active in store consoles
• Wrong API keys

Solutions:

1. Check RevenueCat dashboard → Products → Verify sync status
2. Ensure products are "Active" in App Store Connect/Play Console
3. Verify API keys in your code
4. Wait a few minutes after creating products (propagation delay)

Issue: "Purchase failed" errors

Causes:

• Sandbox account issues
• Product configuration errors
• Network problems

Solutions:

1. Use proper sandbox test accounts
2. Verify product IDs match exactly
3. Check network connectivity
4. Review RevenueCat error logs

Issue: Build fails on EAS

Causes:

• Configuration errors
• Missing dependencies
• Code errors

Solutions:

1. Check eas.json configuration
2. Verify all dependencies are installed
3. Test build locally first: eas build --local
4. Review build logs in EAS dashboard

Issue: App rejected by stores

Causes:

• Missing required information
• Guideline violations
• App crashes or bugs

Solutions:

1. Read rejection reason carefully
2. Address all issues mentioned
3. Test app thoroughly before resubmitting
4. Provide clear explanations in review notes

---

Cost Breakdown

One-Time Costs

• Apple Developer Program: $99/year
• Google Play Developer: $25 one-time
• RevenueCat: Free up to $10k MRR, then 1% of revenue

Monthly Costs (Optional)

• EAS Build: Free tier includes limited builds, then $29/month
• Expo: Free for most use cases
• Hosting: If you have a backend (varies)

Total First-Year Cost

• Minimum: ~$124 (Apple + Google fees)
• With EAS Pro: ~$448 (if you exceed free tier)

---

Resources and Next Steps

Official Documentation

• Expo Documentation
• RevenueCat Documentation
• EAS Build Guide
• App Store Review Guidelines
• Google Play Policy

Helpful Tools

• App Store Connect
• Google Play Console
• RevenueCat Dashboard
• EAS Dashboard

Community Support

• Expo Discord
• RevenueCat Community
• React Native Community

---

Summary

Shipping a mobile app to both App Store and Play Store in one week is achievable with Expo and RevenueCat. The key is:

1. Parallel Processing: Set up both store accounts simultaneously
2. Proper Configuration: Ensure product IDs match across all platforms
3. Thorough Testing: Test all payment flows before submission
4. Complete Listings: Fill out all required store information
5. Monitor Closely: Watch for review feedback and respond quickly

The combination of Expo's simplified build process and RevenueCat's unified payment API eliminates most of the complexity traditionally associated with mobile app development. By following this guide, you can go from zero to live on both stores in 7 days or less.

Remember: The longest wait is usually Apple Developer account approval and store reviews. Start the Apple Developer enrollment immediately, even before your app is ready. Everything else can be done in parallel.

Good luck with your launch! 🚀

---

This guide covers the complete process from setup to submission. For specific issues or advanced use cases, refer to the official documentation or community forums. The mobile app ecosystem evolves quickly, so always check for the latest best practices and requirements.