run sync in separate worker process, update fly.toml to support that

api/.env.example

···
 # Server configuration
 PORT=3000
 
+# Process type: all (everything), app (HTTP + Jetstream), or worker (sync jobs only)
+# PROCESS_TYPE=all
+
 # Authentication service base URL
 AUTH_BASE_URL=http://localhost:8081
 

api/CLAUDE.md

···
    SYSTEM_SLICE_URI=at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z
    AUTH_BASE_URL=http://localhost:8081
    RELAY_ENDPOINT=https://relay1.us-west.bsky.network
+   PROCESS_TYPE=all  # Optional: all (default), app, worker
    ```
+
+### Process Types
+
+The application supports running different components in separate processes for better resource isolation and scaling:
+
+- `all` (default): Everything (HTTP API + Jetstream + sync workers)
+- `app`: HTTP API server + Jetstream real-time indexing
+- `worker`: Background sync job processing only
+
+Set via `PROCESS_TYPE` environment variable (or `FLY_PROCESS_GROUP` on Fly.io).
 
 ## Common Development Commands
 
···
 - **Auth System**: Uses dedicated auth cache for OAuth and AT Protocol session caching
 - **Actor Resolution**: Caches DID resolution results to avoid repeated lookups
 - **Automatic Fallback**: Redis failures automatically fall back to in-memory caching without errors
+
+## Deployment
+
+### Fly.io (Multi-Process Architecture)
+
+The application is configured to run different components in separate process groups on Fly.io:
+
+```toml
+[processes]
+  app = "app"      # HTTP API + Jetstream
+  worker = "worker"  # Sync job processing
+```
+
+**Scale processes independently:**
+```bash
+# Scale app instances (HTTP + Jetstream)
+fly scale count app=2
+
+# Scale sync workers (for heavy backfills)
+fly scale count worker=5
+
+# Different VM sizes per workload
+fly scale vm shared-cpu-1x --process-group app
+fly scale vm shared-cpu-2x --process-group worker
+```

api/fly.toml

···
   AUTH_BASE_URL="https://slices-aip.fly.dev"
   SYSTEM_SLICE_URI="at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z"
 
+[processes]
+  app = "slices"
+  worker = "slices"
+
 [http_service]
   internal_port = 8080
   force_https = true
   auto_stop_machines = 'stop'
   auto_start_machines = true
   min_machines_running = 1
-  processes = ['app']
+  processes = ['app']  # Only app process handles HTTP
 
 [[vm]]
   memory = '1gb'

api/src/jetstream.rs

···
 
     /// Load slice configurations
     pub async fn load_slice_configurations(&self) -> Result<(), JetstreamError> {
-        info!("Jetstream consumer now uses on-demand loading with caching");
+        info!("Loading slice configurations...");
 
         // Get all slices and update cached list
         let slices = self.database.get_all_slices().await?;
         *self.slices_list.write().await = slices.clone();
-        info!(
-            "Found {} total slices in database - data will be loaded on-demand",
-            slices.len()
-        );
+        info!("Found {} total slices in database", slices.len());
 
         Ok(())
     }

api/src/main.rs

···
     // Start log cleanup background task
     start_log_cleanup_task(pool.clone());
 
-    // Start job queue runner
-    let pool_for_runner = pool.clone();
-    tokio::spawn(async move {
-        tracing::info!("Starting job queue runner...");
-        match jobs::registry()
-            .runner(&pool_for_runner)
-            .set_concurrency(1, 2) // Keep 1-2 sync jobs running at a time (reduced for pool management)
-            .run()
-            .await
-        {
-            Ok(handle) => {
-                tracing::info!("Job runner started successfully, keeping handle alive...");
-                // CRITICAL: We must keep the handle alive for the runner to continue processing jobs
-                // The runner will stop if the handle is dropped
-                std::future::pending::<()>().await; // Keep the task alive indefinitely
-                drop(handle); // This line will never be reached
-            }
-            Err(e) => {
-                tracing::error!("Failed to start job runner: {}", e);
+    // Detect process type from environment (supports both PROCESS_TYPE and FLY_PROCESS_GROUP)
+    let process_type = env::var("PROCESS_TYPE")
+        .or_else(|_| env::var("FLY_PROCESS_GROUP"))
+        .unwrap_or_else(|_| "all".to_string());
+
+    info!("Starting with process type: {}", process_type);
+
+    let is_all = process_type == "all";
+    let is_app = process_type == "app";
+    let is_worker = process_type == "worker";
+
+    // Start job queue runner (in worker or all processes)
+    if is_worker || is_all {
+        info!("Starting sync job queue runner for worker process");
+        let pool_for_runner = pool.clone();
+        tokio::spawn(async move {
+            tracing::info!("Starting job queue runner...");
+            match jobs::registry()
+                .runner(&pool_for_runner)
+                .set_concurrency(1, 2) // Keep 1-2 sync jobs running at a time (reduced for pool management)
+                .run()
+                .await
+            {
+                Ok(handle) => {
+                    tracing::info!("Job runner started successfully, keeping handle alive...");
+                    // CRITICAL: We must keep the handle alive for the runner to continue processing jobs
+                    // The runner will stop if the handle is dropped
+                    std::future::pending::<()>().await; // Keep the task alive indefinitely
+                    drop(handle); // This line will never be reached
+                }
+                Err(e) => {
+                    tracing::error!("Failed to start job runner: {}", e);
+                }
             }
-        }
-    });
+        });
+    } else {
+        info!("Skipping sync job queue runner for app process");
+    }
 
     // Create shared jetstream connection status
     let jetstream_connected = Arc::new(AtomicBool::new(false));
 
-    // Start Jetstream consumer with cursor persistence and improved reconnection logic
-    let database_for_jetstream = database.clone();
-    let pool_for_jetstream = pool.clone();
-    let jetstream_connected_clone = jetstream_connected.clone();
-    tokio::spawn(async move {
-        let jetstream_hostname = env::var("JETSTREAM_HOSTNAME").ok();
-        let redis_url = env::var("REDIS_URL").ok();
-        let cursor_write_interval = env::var("JETSTREAM_CURSOR_WRITE_INTERVAL_SECS")
-            .unwrap_or_else(|_| "5".to_string())
-            .parse::<u64>()
-            .unwrap_or(5);
+    // Start Jetstream consumer (in app or all processes)
+    if is_app || is_all {
+        info!("Starting Jetstream consumer for app process");
+        let database_for_jetstream = database.clone();
+        let pool_for_jetstream = pool.clone();
+        let jetstream_connected_clone = jetstream_connected.clone();
+        tokio::spawn(async move {
+            let jetstream_hostname = env::var("JETSTREAM_HOSTNAME").ok();
+            let redis_url = env::var("REDIS_URL").ok();
+            let cursor_write_interval = env::var("JETSTREAM_CURSOR_WRITE_INTERVAL_SECS")
+                .unwrap_or_else(|_| "5".to_string())
+                .parse::<u64>()
+                .unwrap_or(5);
+
+            // Reconnection rate limiting (5 retries per minute max)
+            const MAX_RECONNECTS_PER_MINUTE: u32 = 5;
+            const RECONNECT_WINDOW: tokio::time::Duration = tokio::time::Duration::from_secs(60);
+            let mut reconnect_count = 0u32;
+            let mut window_start = std::time::Instant::now();
 
-        // Reconnection rate limiting (5 retries per minute max)
-        const MAX_RECONNECTS_PER_MINUTE: u32 = 5;
-        const RECONNECT_WINDOW: tokio::time::Duration = tokio::time::Duration::from_secs(60);
-        let mut reconnect_count = 0u32;
-        let mut window_start = std::time::Instant::now();
+            let mut retry_delay = tokio::time::Duration::from_secs(5);
+            const MAX_RETRY_DELAY: tokio::time::Duration = tokio::time::Duration::from_secs(300);
 
-        let mut retry_delay = tokio::time::Duration::from_secs(5);
-        const MAX_RETRY_DELAY: tokio::time::Duration = tokio::time::Duration::from_secs(300);
+            // Configuration reloader setup (run once)
+            let mut config_reloader_started = false;
 
-        // Configuration reloader setup (run once)
-        let mut config_reloader_started = false;
+            loop {
+                // Rate limiting: reset counter if window has passed
+                let now = std::time::Instant::now();
+                if now.duration_since(window_start) >= RECONNECT_WINDOW {
+                    reconnect_count = 0;
+                    window_start = now;
+                }
 
-        loop {
-            // Rate limiting: reset counter if window has passed
-            let now = std::time::Instant::now();
-            if now.duration_since(window_start) >= RECONNECT_WINDOW {
-                reconnect_count = 0;
-                window_start = now;
-            }
+                // Check rate limit
+                if reconnect_count >= MAX_RECONNECTS_PER_MINUTE {
+                    let wait_time = RECONNECT_WINDOW - now.duration_since(window_start);
+                    tracing::warn!(
+                        "Rate limit exceeded: {} reconnects in last minute, waiting {:?}",
+                        reconnect_count,
+                        wait_time
+                    );
+                    tokio::time::sleep(wait_time).await;
+                    continue;
+                }
 
-            // Check rate limit
-            if reconnect_count >= MAX_RECONNECTS_PER_MINUTE {
-                let wait_time = RECONNECT_WINDOW - now.duration_since(window_start);
-                tracing::warn!(
-                    "Rate limit exceeded: {} reconnects in last minute, waiting {:?}",
-                    reconnect_count,
-                    wait_time
-                );
-                tokio::time::sleep(wait_time).await;
-                continue;
-            }
+                reconnect_count += 1;
 
-            reconnect_count += 1;
+                // Read cursor position from database
+                let initial_cursor =
+                    PostgresCursorHandler::read_cursor(&pool_for_jetstream, "default").await;
+                if let Some(cursor) = initial_cursor {
+                    tracing::info!("Resuming from cursor position: {}", cursor);
+                } else {
+                    tracing::info!("No cursor found, starting from latest events");
+                }
 
-            // Read cursor position from database
-            let initial_cursor =
-                PostgresCursorHandler::read_cursor(&pool_for_jetstream, "default").await;
-            if let Some(cursor) = initial_cursor {
-                tracing::info!("Resuming from cursor position: {}", cursor);
-            } else {
-                tracing::info!("No cursor found, starting from latest events");
-            }
+                // Create cursor handler
+                let cursor_handler = Arc::new(PostgresCursorHandler::new(
+                    pool_for_jetstream.clone(),
+                    "default".to_string(),
+                    cursor_write_interval,
+                ));
 
-            // Create cursor handler
-            let cursor_handler = Arc::new(PostgresCursorHandler::new(
-                pool_for_jetstream.clone(),
-                "default".to_string(),
-                cursor_write_interval,
-            ));
+                // Create consumer with cursor support and Redis cache
+                let consumer_result = JetstreamConsumer::new(
+                    database_for_jetstream.clone(),
+                    jetstream_hostname.clone(),
+                    Some(cursor_handler.clone()),
+                    initial_cursor,
+                    redis_url.clone(),
+                )
+                .await;
 
-            // Create consumer with cursor support and Redis cache
-            let consumer_result = JetstreamConsumer::new(
-                database_for_jetstream.clone(),
-                jetstream_hostname.clone(),
-                Some(cursor_handler.clone()),
-                initial_cursor,
-                redis_url.clone(),
-            )
-            .await;
+                let consumer_arc = match consumer_result {
+                    Ok(consumer) => {
+                        let arc = Arc::new(consumer);
 
-            let consumer_arc = match consumer_result {
-                Ok(consumer) => {
-                    let arc = Arc::new(consumer);
+                        // Start configuration reloader only once
+                        if !config_reloader_started {
+                            JetstreamConsumer::start_configuration_reloader(arc.clone());
+                            config_reloader_started = true;
+                        }
 
-                    // Start configuration reloader only once
-                    if !config_reloader_started {
-                        JetstreamConsumer::start_configuration_reloader(arc.clone());
-                        config_reloader_started = true;
+                        arc
                     }
-
-                    arc
-                }
-                Err(e) => {
-                    tracing::error!(
-                        "Failed to create Jetstream consumer: {} - retry in {:?}",
-                        e,
-                        retry_delay
-                    );
-                    jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
-                    tokio::time::sleep(retry_delay).await;
-                    retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
-                    continue;
-                }
-            };
+                    Err(e) => {
+                        tracing::error!(
+                            "Failed to create Jetstream consumer: {} - retry in {:?}",
+                            e,
+                            retry_delay
+                        );
+                        jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
+                        tokio::time::sleep(retry_delay).await;
+                        retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
+                        continue;
+                    }
+                };
 
-            // Reset retry delay on successful creation
-            retry_delay = tokio::time::Duration::from_secs(5);
+                // Reset retry delay on successful creation
+                retry_delay = tokio::time::Duration::from_secs(5);
 
-            tracing::info!("Starting Jetstream consumer with cursor support...");
-            jetstream_connected_clone.store(true, std::sync::atomic::Ordering::Relaxed);
+                tracing::info!("Starting Jetstream consumer with cursor support...");
+                jetstream_connected_clone.store(true, std::sync::atomic::Ordering::Relaxed);
 
-            // Start consuming with cancellation token
-            let cancellation_token = atproto_jetstream::CancellationToken::new();
-            match consumer_arc.start_consuming(cancellation_token).await {
-                Ok(_) => {
-                    tracing::info!("Jetstream consumer shut down normally");
-                    jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
-                }
-                Err(e) => {
-                    tracing::error!("Jetstream consumer failed: {} - will reconnect", e);
-                    jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
-                    tokio::time::sleep(retry_delay).await;
-                    retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
+                // Start consuming with cancellation token
+                let cancellation_token = atproto_jetstream::CancellationToken::new();
+                match consumer_arc.start_consuming(cancellation_token).await {
+                    Ok(_) => {
+                        tracing::info!("Jetstream consumer shut down normally");
+                        jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
+                    }
+                    Err(e) => {
+                        tracing::error!("Jetstream consumer failed: {} - will reconnect", e);
+                        jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
+                        tokio::time::sleep(retry_delay).await;
+                        retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
+                    }
                 }
             }
-        }
-    });
+        });
+    } else {
+        info!("Skipping Jetstream consumer for worker process");
+    }
 
     // Create auth cache for token/session caching (5 minute TTL)
     let redis_url = env::var("REDIS_URL").ok();
···
         .layer(CorsLayer::permissive())
         .with_state(state);
 
-    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
-    let addr = format!("0.0.0.0:{}", port);
+    // Start HTTP server (in app or all processes)
+    if is_app || is_all {
+        info!("Starting HTTP server for app process");
+        let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
+        let addr = format!("0.0.0.0:{}", port);
 
-    let listener = tokio::net::TcpListener::bind(&addr).await?;
-    info!("Server running on http://{}", addr);
+        let listener = tokio::net::TcpListener::bind(&addr).await?;
+        info!("Server running on http://{}", addr);
 
-    axum::serve(listener, app).await?;
+        axum::serve(listener, app).await?;
+    } else {
+        info!("Worker process, no HTTP server started");
+        std::future::pending::<()>().await;
+    }
+
     Ok(())
 }