@icarusmx/creta 1.5.3 → 1.5.6

package/lib/exercises/railway-deployment.md

@@ -0,0 +1,1185 @@
+# Railway Deployment Guide - Node.js Apps
+
+<!-- vim: set foldmethod=marker foldlevel=0: -->
+
+## 📖 LazyVim Reading Guide {{{
+
+**Start with:** `zM` (close all folds) → Navigate with `za` (toggle fold under cursor)
+
+This document uses fold markers `{{{` and `}}}` for organized reading.
+
+**Navigation Tips:**
+- `zM` - Close all folds (see just section headers)
+- `zR` - Open all folds (see everything)
+- `za` - Toggle current fold
+- `zj` - Jump to next fold
+- `zk` - Jump to previous fold
+
+}}}
+
+## 🎯 What You'll Learn {{{
+
+This guide covers the complete Railway deployment workflow for Node.js applications:
+
+1. **Initial Setup** - Install CLI, authenticate, initialize project
+2. **Deploy Node.js/Express** - From local dev to production deployment
+3. **Environment Variables** - Manage secrets and configuration
+4. **Custom Domains** - Set up domains, DNS, and SSL certificates
+
+**Prerequisites:**
+- Node.js and npm installed
+- Git knowledge (basic commands)
+- A Node.js/Express app to deploy (or use example provided)
+- Railway account (free tier available at railway.app)
+
+**Time to complete:** 30-45 minutes
+
+}}}
+
+## 🚂 Part 1: Initial Setup {{{
+
+### Install Railway CLI {{{
+
+**macOS/Linux:**
+```bash
+# Using Homebrew (recommended for macOS)
+brew install railway
+
+# Or using npm (cross-platform)
+npm install -g @railway/cli
+
+# Verify installation
+railway --version
+```
+
+**Expected output:**
+```
+railway version 3.5.0
+```
+
+**Windows:**
+```bash
+# Using npm
+npm install -g @railway/cli
+
+# Or using Scoop
+scoop install railway
+```
+
+**LazyVim Tip:** Open a floating terminal to run commands while reading:
+- `<leader>ft` - Open floating terminal
+- `<C-\><C-n>` - Exit terminal insert mode (go to Normal mode)
+- `<C-w>w` - Cycle between terminal and guide
+- `i` - Back to terminal insert mode (type commands)
+
+}}}
+
+### Login and Authentication {{{
+
+**Step 1: Login via browser**
+```bash
+railway login
+```
+
+**What happens:**
+1. Opens browser to Railway login page
+2. Authenticate with GitHub/Google/Email
+3. CLI receives access token
+4. Token stored in `~/.railway/config.json`
+
+**Expected output:**
+```
+🚝 Logging in...
+✓ Logged in as your-email@example.com
+```
+
+**Verify authentication:**
+```bash
+railway whoami
+```
+
+**Output:**
+```
+Logged in as: Your Name (your-email@example.com)
+```
+
+**Troubleshooting:**
+- If browser doesn't open: `railway login --browserless`
+- Manual token: Get from railway.app/account/tokens
+
+}}}
+
+### Initialize Project {{{
+
+**Two ways to start:**
+
+#### Option 1: Link Existing Railway Project
+```bash
+# If you already created a project on Railway dashboard
+cd your-app-directory
+railway link
+```
+
+**Interactive prompt:**
+```
+Select a project:
+> my-express-api
+  my-portfolio-site
+  test-project
+```
+
+#### Option 2: Create New Project from CLI
+```bash
+cd your-app-directory
+railway init
+```
+
+**Prompts you'll see:**
+```
+Enter project name: my-express-api
+Select environment: production
+✓ Project created: my-express-api
+```
+
+**Verify project setup:**
+```bash
+railway status
+```
+
+**Output:**
+```
+Project: my-express-api
+Environment: production
+Service: Not deployed yet
+```
+
+**LazyVim Workflow:**
+- Use `<leader>/` to search "railway init" in this file
+- Press `n` to jump to next occurrence
+- Press `N` to go back
+
+}}}
+
+### Understanding Railway Project Structure {{{
+
+**After initialization, Railway creates:**
+```
+your-app/
+├── .railway/          # Railway metadata (gitignored)
+│   └── config.json    # Project/service mapping
+├── railway.json       # Deployment configuration (optional)
+├── railway.toml       # Alternative config format (optional)
+└── your app files...
+```
+
+**Important:**
+- `.railway/` is automatically added to `.gitignore`
+- `railway.json` defines build/deploy settings (we'll create this next)
+
+}}}
+
+}}}
+
+## 🚀 Part 2: Deploy Node.js/Express Apps {{{
+
+### Prepare Your Express App {{{
+
+**Example Express App Structure:**
+```
+my-express-api/
+├── package.json
+├── index.js           # or server.js
+├── .env               # Local env vars (gitignored)
+├── .gitignore
+└── README.md
+```
+
+**Minimal Express App (index.js):**
+```javascript
+import express from 'express'
+
+const app = express()
+const PORT = process.env.PORT || 3000
+
+app.get('/', (req, res) => {
+  res.json({ message: 'Hello from Railway!' })
+})
+
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', timestamp: new Date() })
+})
+
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`)
+})
+```
+
+**package.json Requirements:**
+```json
+{
+  "name": "my-express-api",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node --watch index.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
+```
+
+**Critical: Specify `start` script!** Railway runs `npm start` by default.
+
+**LazyVim Tip:** Use `gf` (go to file) on `"./index.js"` to quickly navigate to that file.
+
+}}}
+
+### Create railway.json Config {{{
+
+**Purpose:** Define build and deployment behavior explicitly.
+
+**Create `railway.json` in project root:**
+```json
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "NIXPACKS",
+    "buildCommand": "npm install"
+  },
+  "deploy": {
+    "startCommand": "npm start",
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 3
+  }
+}
+```
+
+**Configuration explained:**
+
+| Field | Purpose | Options |
+|-------|---------|---------|
+| `builder` | Build system | `NIXPACKS` (auto-detect), `DOCKERFILE` (use Dockerfile) |
+| `buildCommand` | Install dependencies | `npm install`, `npm ci`, `pnpm install` |
+| `startCommand` | Run the app | `npm start`, `node index.js` |
+| `restartPolicyType` | When to restart | `ON_FAILURE`, `ALWAYS`, `NEVER` |
+
+**Advanced: Multiple environments:**
+```json
+{
+  "environments": {
+    "production": {
+      "deploy": {
+        "startCommand": "npm start"
+      }
+    },
+    "staging": {
+      "deploy": {
+        "startCommand": "npm run start:staging"
+      }
+    }
+  }
+}
+```
+
+**LazyVim Editing:**
+- `ci{` - Change inside braces (replace JSON value)
+- `va{` - Select entire object (visual select around braces)
+
+}}}
+
+### Deploy with railway up {{{
+
+**The magic command:**
+```bash
+railway up
+```
+
+**What happens (step by step):**
+```
+1. 📦 Creating deployment...
+2. 🔨 Building application...
+   - Detecting build system: Nixpacks
+   - Installing dependencies: npm install
+   - Running build command (if specified)
+3. 🚀 Deploying...
+   - Creating container
+   - Starting service
+   - Assigning public URL
+4. ✓ Deployment successful!
+   - URL: https://my-express-api-production.up.railway.app
+```
+
+**Expected output:**
+```
+⚡ Deploying...
+✓ Build successful
+✓ Deployment live at https://my-express-api-production.up.railway.app
+
+Deployment ID: d3pl0ym3nt-1234
+Service: my-express-api
+Environment: production
+```
+
+**Verify deployment:**
+```bash
+# Open in browser
+railway open
+
+# Or curl the health endpoint
+curl https://your-app.up.railway.app/health
+```
+
+**First-time deployment:**
+- Usually takes 2-5 minutes
+- Subsequent deploys are faster (cached layers)
+
+}}}
+
+### Monitor Logs and Debugging {{{
+
+**View live logs:**
+```bash
+railway logs
+```
+
+**Output (real-time stream):**
+```
+[2025-01-15 10:30:45] Server running on port 3000
+[2025-01-15 10:30:50] GET /health 200 15ms
+[2025-01-15 10:31:00] GET / 200 8ms
+```
+
+**Follow logs (like tail -f):**
+```bash
+railway logs --follow
+```
+
+**Filter logs by service:**
+```bash
+railway logs --service my-express-api
+```
+
+**Common deployment errors:**
+
+#### Error 1: Build Failed
+```
+Error: Cannot find module 'express'
+```
+**Fix:** Add `express` to `package.json` dependencies
+
+#### Error 2: Port Binding
+```
+Error: listen EADDRINUSE: address already in use :::3000
+```
+**Fix:** Use `process.env.PORT` (Railway assigns dynamic port)
+
+```javascript
+// ❌ Wrong
+const PORT = 3000
+
+// ✅ Correct
+const PORT = process.env.PORT || 3000
+```
+
+#### Error 3: Start Command Failed
+```
+Error: Missing script: "start"
+```
+**Fix:** Add to `package.json`:
+```json
+"scripts": {
+  "start": "node index.js"
+}
+```
+
+**LazyVim Debugging Workflow:**
+1. `<leader>ft` - Open floating terminal
+2. `railway logs` - Watch errors in real-time
+3. `<C-\><C-n>` - Exit terminal insert mode
+4. `<C-w>w` - Switch back to code
+5. Fix issue
+6. `<C-w>w` - Back to terminal, then `i` to type
+7. `git commit && railway up`
+
+}}}
+
+### Redeploy After Changes {{{
+
+**Automatic deploys (recommended):**
+```bash
+# Connect GitHub repo to Railway
+railway link
+
+# Enable auto-deploys on Railway dashboard
+# Now every git push triggers deployment
+```
+
+**Manual redeploy:**
+```bash
+# Make changes to your code
+git add .
+git commit -m "fix: correct port binding"
+
+# Deploy to Railway
+railway up
+```
+
+**Rollback to previous deployment:**
+```bash
+railway rollback
+```
+
+**View deployment history:**
+```bash
+railway deployments
+```
+
+**Output:**
+```
+ID          Status      Created         Duration
+d3pl0y-5    ACTIVE      2 hours ago     1m 30s
+d3pl0y-4    SUCCESS     5 hours ago     1m 45s
+d3pl0y-3    FAILED      1 day ago       0m 20s
+```
+
+}}}
+
+}}}
+
+## 🔐 Part 3: Environment Variables & Secrets {{{
+
+### Setting Variables via CLI {{{
+
+**Add single variable:**
+```bash
+railway variables set DATABASE_URL="postgresql://user:pass@host:5432/db"
+```
+
+**Add multiple variables:**
+```bash
+railway variables set \
+  NODE_ENV=production \
+  API_KEY=sk_live_abc123 \
+  MAX_CONNECTIONS=100
+```
+
+**List all variables:**
+```bash
+railway variables
+```
+
+**Output:**
+```
+Name              Value
+DATABASE_URL      postgresql://...
+NODE_ENV          production
+API_KEY           sk_live_***  (hidden for security)
+MAX_CONNECTIONS   100
+```
+
+**Delete variable:**
+```bash
+railway variables delete API_KEY
+```
+
+**Bulk import from .env file:**
+```bash
+railway variables set --from-env-file .env.production
+```
+
+}}}
+
+### Using .env Files Locally {{{
+
+**Local development setup:**
+
+**1. Create `.env` (local only, gitignored):**
+```bash
+# .env
+NODE_ENV=development
+PORT=3000
+DATABASE_URL=postgresql://localhost:5432/mydb_dev
+API_KEY=sk_test_abc123
+```
+
+**2. Add to `.gitignore`:**
+```bash
+# .gitignore
+.env
+.env.*
+!.env.example
+```
+
+**3. Create `.env.example` (committed to repo):**
+```bash
+# .env.example
+NODE_ENV=development
+PORT=3000
+DATABASE_URL=postgresql://localhost:5432/dbname
+API_KEY=your_api_key_here
+```
+
+**4. Load variables in code:**
+```javascript
+// index.js
+import 'dotenv/config'  // Load .env file
+
+const config = {
+  nodeEnv: process.env.NODE_ENV,
+  port: process.env.PORT || 3000,
+  databaseUrl: process.env.DATABASE_URL,
+  apiKey: process.env.API_KEY
+}
+
+console.log('Config loaded:', config.nodeEnv)
+```
+
+**Install dotenv:**
+```bash
+npm install dotenv
+```
+
+**Railway automatically loads env vars** - no dotenv needed in production!
+
+}}}
+
+### Secrets Management Best Practices {{{
+
+**1. Never commit secrets:**
+```bash
+# ❌ Bad
+git add .env
+git commit -m "add environment variables"
+
+# ✅ Good
+# Add .env to .gitignore BEFORE committing
+echo ".env" >> .gitignore
+```
+
+**2. Use Railway's built-in variables:**
+
+Railway provides these automatically:
+```bash
+RAILWAY_ENVIRONMENT       # production, staging, etc.
+RAILWAY_PROJECT_ID        # Unique project ID
+RAILWAY_SERVICE_ID        # Unique service ID
+RAILWAY_DEPLOYMENT_ID     # Current deployment ID
+RAILWAY_PUBLIC_DOMAIN     # Your app's URL
+```
+
+**Access in code:**
+```javascript
+if (process.env.RAILWAY_ENVIRONMENT === 'production') {
+  // Production-only logic
+}
+```
+
+**3. Separate secrets by environment:**
+```bash
+# Production
+railway variables set --environment production \
+  DATABASE_URL=postgresql://prod-host/db
+
+# Staging
+railway variables set --environment staging \
+  DATABASE_URL=postgresql://staging-host/db
+```
+
+**4. Rotate secrets regularly:**
+```bash
+# Generate new API key
+NEW_KEY=$(openssl rand -hex 32)
+
+# Update Railway
+railway variables set API_KEY=$NEW_KEY
+
+# Trigger redeploy
+railway up
+```
+
+**5. Validate required variables:**
+```javascript
+// config.js
+const requiredVars = [
+  'DATABASE_URL',
+  'API_KEY',
+  'JWT_SECRET'
+]
+
+for (const varName of requiredVars) {
+  if (!process.env[varName]) {
+    throw new Error(`Missing required env var: ${varName}`)
+  }
+}
+```
+
+**LazyVim Tip:**
+- Search for env vars: `<leader>/` then type `process.env.`
+- Jump between matches with `n` and `N`
+
+}}}
+
+### Using Railway Plugins for Databases {{{
+
+**Add PostgreSQL database:**
+```bash
+railway add
+```
+
+**Interactive prompt:**
+```
+Select a plugin to add:
+> PostgreSQL
+  MySQL
+  MongoDB
+  Redis
+```
+
+**Railway automatically sets:**
+```bash
+DATABASE_URL=postgresql://user:pass@host:5432/railway
+PGHOST=containers-us-west-1.railway.app
+PGPORT=5432
+PGUSER=postgres
+PGPASSWORD=generated_password
+PGDATABASE=railway
+```
+
+**Connect in your app:**
+```javascript
+import pg from 'pg'
+const { Pool } = pg
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: { rejectUnauthorized: false }  // Railway requires SSL
+})
+
+// Test connection
+const client = await pool.connect()
+console.log('Database connected!')
+client.release()
+```
+
+**Install pg driver:**
+```bash
+npm install pg
+```
+
+}}}
+
+}}}
+
+## 🌐 Part 4: Custom Domains & Networking {{{
+
+### Add Custom Domain {{{
+
+**Prerequisites:**
+- Own a domain (from Namecheap, Google Domains, etc.)
+- Access to DNS settings
+
+**Add domain via CLI:**
+```bash
+railway domain
+```
+
+**Interactive prompt:**
+```
+Enter custom domain: api.yourdomain.com
+✓ Domain added: api.yourdomain.com
+⚠️  DNS not configured yet - see instructions below
+```
+
+**Or specify directly:**
+```bash
+railway domain add api.yourdomain.com
+```
+
+**View current domains:**
+```bash
+railway domain list
+```
+
+**Output:**
+```
+Domain                              Status        Service
+my-app.up.railway.app              Active        my-express-api (auto)
+api.yourdomain.com                  Pending       my-express-api (custom)
+```
+
+**Remove domain:**
+```bash
+railway domain remove api.yourdomain.com
+```
+
+}}}
+
+### Configure DNS Settings {{{
+
+**Railway provides DNS instructions after adding domain.**
+
+**Step 1: Get DNS records**
+```bash
+railway domain --service my-express-api
+```
+
+**Output:**
+```
+Domain: api.yourdomain.com
+Status: Pending DNS verification
+
+Add these records to your DNS provider:
+Type    Name    Value
+CNAME   api     my-app.up.railway.app
+```
+
+**Step 2: Add CNAME record at your DNS provider**
+
+**Example: Cloudflare**
+```
+Type: CNAME
+Name: api
+Target: my-app.up.railway.app
+Proxy: OFF (or ON, both work)
+TTL: Auto
+```
+
+**Example: Namecheap**
+```
+Type: CNAME Record
+Host: api
+Value: my-app.up.railway.app
+TTL: Automatic
+```
+
+**Step 3: Wait for DNS propagation**
+```bash
+# Check DNS propagation
+dig api.yourdomain.com
+
+# Or use online tool
+# https://dnschecker.org/#CNAME/api.yourdomain.com
+```
+
+**Propagation time:** 5 minutes to 48 hours (usually ~1 hour)
+
+**Step 4: Verify in Railway**
+```bash
+railway domain list
+```
+
+**Once verified:**
+```
+Domain                    Status        SSL
+api.yourdomain.com       Active        Provisioning...
+```
+
+**SSL certificate is automatic!** Railway uses Let's Encrypt.
+
+}}}
+
+### SSL/TLS Certificates {{{
+
+**Railway handles SSL automatically:**
+1. You add custom domain
+2. DNS verification completes
+3. Railway provisions Let's Encrypt cert (free)
+4. HTTPS enabled automatically
+
+**No configuration needed!**
+
+**Verify SSL:**
+```bash
+curl -I https://api.yourdomain.com
+```
+
+**Look for:**
+```
+HTTP/2 200
+server: Railway
+x-forwarded-proto: https
+strict-transport-security: max-age=31536000
+```
+
+**Force HTTPS in your app (optional):**
+```javascript
+// middleware/force-https.js
+export function forceHTTPS(req, res, next) {
+  if (process.env.NODE_ENV === 'production' &&
+      req.headers['x-forwarded-proto'] !== 'https') {
+    return res.redirect(301, `https://${req.headers.host}${req.url}`)
+  }
+  next()
+}
+
+// index.js
+import { forceHTTPS } from './middleware/force-https.js'
+app.use(forceHTTPS)
+```
+
+**SSL certificate renewal:** Automatic (every 60 days)
+
+}}}
+
+### Database Connections {{{
+
+**Railway networking:**
+- Services within same project can communicate via **private network**
+- No public internet needed for internal connections
+
+**Connect to PostgreSQL from your app:**
+
+**Option 1: Use DATABASE_URL (simplest)**
+```javascript
+import pg from 'pg'
+const pool = new pg.Pool({
+  connectionString: process.env.DATABASE_URL
+})
+```
+
+**Option 2: Use individual env vars**
+```javascript
+const pool = new pg.Pool({
+  host: process.env.PGHOST,
+  port: process.env.PGPORT,
+  database: process.env.PGDATABASE,
+  user: process.env.PGUSER,
+  password: process.env.PGPASSWORD,
+  ssl: { rejectUnauthorized: false }
+})
+```
+
+**Connection pooling best practices:**
+```javascript
+const pool = new pg.Pool({
+  connectionString: process.env.DATABASE_URL,
+  max: 20,                    // Max connections in pool
+  idleTimeoutMillis: 30000,   // Close idle connections after 30s
+  connectionTimeoutMillis: 2000  // Fail fast if can't connect
+})
+
+// Graceful shutdown
+process.on('SIGTERM', async () => {
+  await pool.end()
+  process.exit(0)
+})
+```
+
+**Test database connection:**
+```javascript
+async function testConnection() {
+  try {
+    const client = await pool.connect()
+    const result = await client.query('SELECT NOW()')
+    console.log('Database connected:', result.rows[0].now)
+    client.release()
+  } catch (err) {
+    console.error('Database connection failed:', err)
+    process.exit(1)
+  }
+}
+
+testConnection()
+```
+
+}}}
+
+### CORS Configuration {{{
+
+**Allow requests from your frontend domain:**
+
+```javascript
+import cors from 'cors'
+
+const allowedOrigins = [
+  'https://yourdomain.com',
+  'https://www.yourdomain.com',
+  process.env.RAILWAY_ENVIRONMENT === 'development' && 'http://localhost:3000'
+].filter(Boolean)
+
+app.use(cors({
+  origin: allowedOrigins,
+  credentials: true,
+  methods: ['GET', 'POST', 'PUT', 'DELETE'],
+  allowedHeaders: ['Content-Type', 'Authorization']
+}))
+```
+
+**Install cors:**
+```bash
+npm install cors
+```
+
+**Test CORS:**
+```bash
+curl -H "Origin: https://yourdomain.com" \
+     -H "Access-Control-Request-Method: POST" \
+     -X OPTIONS \
+     https://api.yourdomain.com/endpoint
+```
+
+**Expected headers in response:**
+```
+Access-Control-Allow-Origin: https://yourdomain.com
+Access-Control-Allow-Methods: GET, POST, PUT, DELETE
+Access-Control-Allow-Credentials: true
+```
+
+}}}
+
+}}}
+
+## 🎓 Quick Reference {{{
+
+### Common Commands Cheat Sheet {{{
+
+**Authentication:**
+```bash
+railway login          # Login via browser
+railway logout         # Logout
+railway whoami         # Show current user
+```
+
+**Project Management:**
+```bash
+railway init           # Create new project
+railway link           # Link to existing project
+railway status         # Show project info
+railway list           # List all projects
+```
+
+**Deployment:**
+```bash
+railway up             # Deploy current directory
+railway up --detach    # Deploy without watching logs
+railway logs           # View logs
+railway logs -f        # Follow logs (tail -f)
+railway open           # Open app in browser
+```
+
+**Environment Variables:**
+```bash
+railway variables                    # List all vars
+railway variables set KEY=value      # Set variable
+railway variables delete KEY         # Delete variable
+railway variables --environment staging  # Target specific env
+```
+
+**Domains:**
+```bash
+railway domain                       # Interactive domain management
+railway domain add example.com       # Add custom domain
+railway domain list                  # List all domains
+railway domain remove example.com    # Remove domain
+```
+
+**Plugins:**
+```bash
+railway add            # Add plugin (database, Redis, etc.)
+railway plugins        # List plugins
+railway remove         # Remove plugin
+```
+
+**Utilities:**
+```bash
+railway run node script.js    # Run command with Railway env vars
+railway shell                 # Open shell with env vars loaded
+railway environment           # Switch environment
+railway service               # Manage services
+```
+
+}}}
+
+### Troubleshooting Guide {{{
+
+**Problem: Build fails with "command not found"**
+```
+Error: sh: npm: command not found
+```
+**Solution:** Specify Node.js version in `railway.json`:
+```json
+{
+  "build": {
+    "builder": "NIXPACKS"
+  },
+  "deploy": {
+    "nixpacksVersion": "1.x"
+  }
+}
+```
+
+---
+
+**Problem: App crashes immediately after deploy**
+```
+Error: Application exited with code 1
+```
+**Debug:**
+```bash
+railway logs --tail 100
+```
+**Common causes:**
+- Missing environment variables
+- Port binding to hardcoded port instead of `process.env.PORT`
+- Missing `start` script in package.json
+
+---
+
+**Problem: Environment variables not loading**
+```javascript
+console.log(process.env.MY_VAR)  // undefined
+```
+**Solution:**
+1. Check variable is set: `railway variables`
+2. Restart app: `railway up`
+3. Verify environment: `railway status`
+
+---
+
+**Problem: Database connection timeout**
+```
+Error: connect ETIMEDOUT
+```
+**Checklist:**
+- [ ] DATABASE_URL is set: `railway variables | grep DATABASE`
+- [ ] SSL is enabled in connection: `ssl: { rejectUnauthorized: false }`
+- [ ] Database plugin is running: `railway plugins`
+- [ ] Network connectivity: Database and app in same project?
+
+---
+
+**Problem: Custom domain shows "DNS not configured"**
+```
+Status: Pending DNS verification
+```
+**Steps:**
+1. Verify CNAME record exists at DNS provider
+2. Check DNS propagation: `dig yourdomain.com`
+3. Wait up to 48 hours (usually ~1 hour)
+4. Use DNS checker: https://dnschecker.org
+
+---
+
+**Problem: High memory usage / crashes**
+```
+Error: JavaScript heap out of memory
+```
+**Solution:** Increase Node.js memory limit:
+```json
+{
+  "deploy": {
+    "startCommand": "node --max-old-space-size=4096 index.js"
+  }
+}
+```
+
+Or upgrade Railway plan for more resources.
+
+---
+
+**Problem: Slow cold starts**
+
+**Optimization strategies:**
+1. **Reduce dependencies:** Review `package.json`, remove unused packages
+2. **Use build cache:** Railway caches `node_modules` between deploys
+3. **Lazy load modules:** Only import what you need when you need it
+4. **Optimize Docker layers:** If using Dockerfile, order commands by change frequency
+
+---
+
+**Get help:**
+- Railway Docs: https://docs.railway.app
+- Railway Discord: https://discord.gg/railway
+- Railway CLI help: `railway --help`
+
+}}}
+
+### LazyVim Workflow Summary {{{
+
+**Quick navigation in this file:**
+```vim
+zM              " Close all folds - see outline
+/railway up     " Search for deployment command
+n               " Next match
+za              " Toggle fold under cursor
+<leader>ft      " Open floating terminal to run commands
+```
+
+**Working with code:**
+```vim
+gf              " Go to file under cursor
+gd              " Go to definition
+K               " Show hover docs
+<leader>/       " Search across entire project
+```
+
+**Editing tricks:**
+```vim
+ci"             " Change inside quotes (update URLs)
+ci{             " Change inside braces (edit JSON)
+>>              " Indent line
+=i{             " Auto-format JSON object
+```
+
+**Terminal integration:**
+```vim
+<leader>ft      " Open floating terminal
+<C-\><C-n>      " Exit terminal insert mode → Normal mode
+<C-w>w          " Cycle between terminal and code
+i               " Back to terminal insert mode (type commands)
+:terminal       " Alternative: open terminal in current window
+```
+
+}}}
+
+}}}
+
+## 🎯 Next Steps {{{
+
+**After completing this guide, you should be able to:**
+- ✅ Deploy Node.js apps to Railway from CLI
+- ✅ Manage environment variables and secrets
+- ✅ Configure custom domains with SSL
+- ✅ Connect databases and manage networking
+- ✅ Debug deployment issues with logs
+
+**Level up your deployment skills:**
+1. **Add CI/CD:** Connect GitHub for auto-deploys on push
+2. **Multi-environment setup:** Create staging + production environments
+3. **Monitoring:** Set up health checks and alerts
+4. **Scaling:** Configure autoscaling for high traffic
+5. **Database migrations:** Learn Railway's migration workflows
+
+**Resources:**
+- Railway Docs: https://docs.railway.app
+- Railway Templates: https://railway.app/templates
+- Railway Discord: https://discord.gg/railway
+- This guide in Creta: `creta` → "Practicar con ejercicios" → "Railway Deployment Guide"
+
+}}}
+
+---
+
+**💡 Pro Tip:** Keep this guide open in LazyVim while deploying with Railway CLI!
+
+**Terminal Workflow:**
+1. Open this guide: `nvim lib/exercises/railway-deployment.md`
+2. `<leader>ft` - Open floating terminal
+3. Type Railway commands (e.g., `railway up`)
+4. `<C-\><C-n>` - Exit terminal insert mode (to Normal mode)
+5. `<C-w>w` - Cycle back to guide to read next steps
+6. `<C-w>w` - Back to terminal
+7. `i` - Enter insert mode to type more commands
+8. Repeat steps 3-7 as you work through the guide!
+
+**Quick reference:**
+- `<leader>ft` → Open terminal
+- `<C-\><C-n>` → Exit terminal typing mode
+- `<C-w>w` → Switch windows
+- `i` → Start typing in terminal
+
+**🏛️ Salgamos de este laberinto** - Happy deploying with Railway! 🚂