Deploying Your App: GitHub, Railway, Apify & Google Auth

From Code to Live Web App: The Complete Deployment Process

You've built your social listening tool with Claude AI, but now comes the exciting part — making it accessible to your entire team. This walkthrough covers the complete deployment process using GitHub, Railway, and Google Authentication to transform your local project into a professional web application.

The deployment stack we'll use includes GitHub for version control, Railway for hosting, custom domain configuration, and Google OAuth for secure team access. These tools work together to create a professional deployment pipeline that rivals what development teams use at major companies.

Setting Up GitHub Repository

The first step in deployment involves getting your code into version control. When you prompt Claude to prepare your project for GitHub deployment, it automatically handles sensitive information by ensuring API keys and private data stay in environment variables rather than being pushed to the public repository.

Here's the GitHub setup process:

1. Create the repository using GitHub Desktop
2. Add your existing project folder as the repository source
3. Name your repository descriptively (like "social-listening-tool")
4. Organize your file structure — keep each project in its own dedicated folder to avoid mixing codebases

The importance of clean file organization cannot be overstated. When you're managing multiple Claude-built projects, having separate folders for each tool prevents conflicts and makes deployment significantly smoother.

After creating the repository locally, you'll publish it to GitHub, making your code available for the hosting service to access. This creates the foundation for automated deployments whenever you make changes.

Railway Hosting Configuration

Railway provides an elegant hosting solution that automatically detects your project type and configures the deployment environment. The platform connects directly to your GitHub repository, enabling continuous deployment whenever you push code changes.

The Railway setup involves several key steps:

Repository Connection: Railway pulls your code directly from GitHub, automatically detecting it as a web application and configuring the appropriate build settings.

Environment Variables: This is where your API keys and sensitive configuration live. Rather than hardcoding these values in your source code, Railway's environment variable system keeps them secure while making them available to your application at runtime.

Build Process: Railway handles the technical deployment details — installing dependencies, building your application, and managing the server infrastructure.

If you encounter an empty repository error during deployment, it typically means the local files weren't properly committed to GitHub. Going back to GitHub Desktop to commit and publish your changes resolves this issue.

Custom Domain Setup

Professional web applications deserve professional URLs. Setting up a custom domain transforms your Railway-generated URL into something branded and memorable for your team.

The domain configuration process requires coordination between Railway and your domain provider:

Railway Domain Configuration:

• Add your custom domain in Railway's networking settings
• Railway provides CNAME and TXT records for verification
• Configure the domain to use port 8080

DNS Provider Setup:

• Add the CNAME record pointing to Railway's servers
• Include the TXT record for domain verification
• Wait for DNS propagation (usually a few minutes)

Each domain provider has slightly different interfaces for managing DNS records. Whether you're using GoDaddy, Squarespace, or another registrar, the process involves adding Railway's provided records to verify domain ownership and route traffic correctly.

Implementing Google Authentication

A public web application accessible to anyone isn't practical for internal tools. Google Authentication provides secure, team-specific access control that integrates seamlessly with your existing Google Workspace setup.

Google Cloud Console Configuration

Setting up Google OAuth requires creating a new project in Google Cloud Console:

1. Create a new project (name it descriptively, like "growth-pair-pulse")
2. Enable APIs and Services for OAuth functionality
3. Create OAuth 2.0 credentials for web application access
4. Configure authorized domains for both local development and production

The credential configuration includes:

• Authorized JavaScript origins: Your local development URL and production domain
• Authorized redirect URIs: Where Google sends users after authentication
• Client restrictions: Limiting access to specific email domains

Railway Environment Variables

Google authentication requires adding several new environment variables to Railway:

• GOOGLE_CLIENT_ID: Public identifier for your OAuth application
• GOOGLE_CLIENT_SECRET: Private key for secure authentication
• Additional OAuth configuration: Callback URLs and session management

These variables connect your web application to Google's authentication system, enabling the "Sign in with Google" functionality while restricting access to your specified domain.

The Deployment Workflow

Understanding the development-to-production workflow is crucial for maintaining and updating your application. This process follows standard software development practices:

Local Development: Make changes on your computer using Claude AI to modify and enhance functionality.

Version Control: Commit changes to GitHub Desktop with descriptive messages about what was added or modified.

Automatic Deployment: Railway monitors your GitHub repository and automatically deploys new commits to your live website.

Testing and Iteration: Verify changes work correctly, then repeat the process for additional improvements.

This workflow means your team always has access to the latest version while you maintain complete control over when updates go live.

Debugging Real Deployment Issues

Deployments rarely work perfectly on the first attempt. Common issues include:

Environment Variable Mismatches: Double-check that API keys are added to the correct project and match exactly what your code expects.

Domain Configuration Errors: DNS changes can take time to propagate, and incorrect CNAME records prevent proper routing.

Authentication Setup Problems: Google OAuth is sensitive to exact URL matches — ensure your authorized domains precisely match your actual URLs.

GitHub Sync Issues: Sometimes local changes don't properly sync to GitHub, requiring manual commit and push operations.

The key to successful debugging is systematic checking of each component. Claude AI excels at helping diagnose deployment issues when you provide specific error messages.

Security and Access Control

Your deployed application now includes enterprise-grade security features:

Domain-Restricted Authentication: Only users with email addresses from your specified domain can access the application.

Secure Environment Variables: API keys and sensitive configuration remain protected in Railway's secure environment system.

HTTPS Encryption: Railway automatically provides SSL certificates for secure data transmission.

Session Management: Google OAuth handles user sessions securely without requiring custom authentication code.

Key Takeaways

• GitHub provides professional version control that enables automated deployments and code collaboration across your team
• Railway simplifies hosting complexity by automatically configuring servers, managing deployments, and providing secure environment variable storage
• Custom domains create professional user experiences and require coordination between hosting platforms and DNS providers
• Google Authentication adds enterprise security while maintaining simple user experience through familiar Google sign-in
• The iterative deployment workflow mirrors professional development practices and allows continuous improvement of your Claude-built applications