시네마틱 3D 액션 광고 - [제품/브랜드 삽입], 극적인 스튜디

### 🔴 Critical Issues 1. **Edge Function Cold Start During App Launch** - **Issue**: The `auth-guard` Edge Function is likely invoked during app cold start (session restore) to validate tokens. This stacks with the mobile app's own cold start, causing a visible delay before the user sees any content. - **Why**: Edge Functions spin up on-demand; if the function has heavy imports (e.g., `supabase-js`, `jose` for JWT verification), the cold start can take 500-1500ms. On a slow mobile network, this compounds with the initial request latency. - **Impact**: UX-breaking - the user stares at a splash screen or blank UI during this period. 2. **Blocking UI on Edge Responses** - **Issue**: User-triggered actions (e.g., profile update, content submission) appear to synchronously await Edge Function responses before updating the UI. No optimistic UI or background execution is evident. - **Why**: On unstable networks, this creates a perceived freeze. The mobile app's main thread is blocked waiting for a network round-trip, which can take seconds. - **Impact**: UX-breaking - users may tap repeatedly, abandon the action, or perceive the app as broken. 3. **Heavy AI/External API Orchestration in Edge Functions** - **Issue**: An Edge Function appears to orchestrate external AI calls (e.g., OpenAI, Anthropic)or multiple third-party APIs sequentially. - **Why**: Edge Functions have execution time limits (typically 15-60s) and are not designed for long-running, I/O-heavy orchestration. On mobile, this means the user's request hangs indefinitely if the Edge Function times out or fails mid-orchestration. - **Impact**: UX-breaking - no fallback, no partial results, and the mobile client receives a generic error after a long wait. --- ### 🟠 Moderate Risks 1. **Eager Imports & Global-Scope Side Effects** - **Issue**: Edge Functions import large libraries eagerly (e.g., `supabase-js` for every function, even those only needing a simple DB query) and may initialize clients at global scope. - **Why**: This increases cold start time unnecessarily. Global-scope side effects (e.g., creating a Supabase client at module load)force the runtime to execute setup code before handling any request. - **Impact**: Noticeable - adds 100-300ms to every cold start, even for trivial functions. . 2. **Edge Function Classification Misalignment** - **Issue**: Some functions classified as "External API proxy" or "Heavy compute" are placed in Edge, but they should be on a Server or Worker. - **Why**: Edge Functions are stateless and ephemeral; they lack persistent connections or caching layers needed for efficient external API proxying. Heavy compute tasks (e.g., image processing, complex aggregations)are better suited for dedicated workers with longer timeouts. - **Impact**: Noticeable - increased latency and higher failure rates under load, especially on mobile networks where retries are costly. . 3. **No Background Execution for Non-Critical Tasks** - **Issue**: Non-critical updates (e.g., analytics, logging, cache refresh)appear to be sent synchronously via Edge Functions, blocking the main flow. - **Why**: Mobile users don't need to wait for these. They should be fire-and-forget or batched. - **Impact**: Noticeable - adds unnecessary latency to otherwise quick actions, degrading perceived performance. . --- ### 🟢 Acceptable / Well-Designed Areas 1. **Auth / Guard Functions Are Correctly Placed** - **Issue**: Using Edge Functions for token validation and policy checks is appropriate. - **Why**: They are stateless, fast to execute, and can be cached at the edge. This reduces round-trip time compared to a centralized server. - **Impact**: Positive - if optimized, this is a good use case for Edge. 2. **Validation / Policy Logic Is Lightweight** - **Issue**: Basic input validation and policy enforcement are done in Edge Functions, which is fine. - **Why**: These are short-lived, deterministic operations that benefit from edge proximity. - **Impact**: Positive - minimal cold start impact if imports are kept lean. . 3. **Separation of Concerns** - **Issue**: The codebase separates auth, validation, and orchestration into distinct Edge Functions. - **Why**: This allows independent scaling and caching. It also prevents a single heavy function from blocking all other operations. - **Impact**: Positive - good architectural hygiene, though execution needs optimization. . --- ### 📋 Recommendations (Strict Rules) 1. **Optimize Edge Function Imports & Initialization** - **What**: Refactor Edge Functions to use lazy imports inside the handler function, and avoid global-scope client initialization. Use lightweight JWT verification libraries (e.g., `jose` instead of full `supabase-js` for auth checks). - **Why**: Reduces cold start time by 30-50% for each function. Mobile users experience faster session restore and initial loads. - **Impact**: UX - cold start drops from "UX-breaking" to "Noticeable" or "Invisible". Latency - 200-500ms saved per cold call. 2. **Implement Optimistic UI for User-Triggered Actions** - **What**: For actions like profile updates or content submissions, update the UI immediately, then fire the Edge Function in the background. Show a subtle "syncing" indicator, and handle errors with a retry prompt. - **Why**: Eliminates perceived freeze on mobile. Users see instant feedback, improving perceived performance dramatically. - **Impact**: UX - from "UX-breaking" to "Invisible" for most interactions. Reliability - reduces duplicate taps and user frustration. . 3. **Move Heavy Orchestration to a Server or Worker** - **What**: Relocate Edge Functions that orchestrate external AI calls or long-running tasks to a dedicated server (e.g., Supabase Serverless Functions with longer timeouts)or a background worker. - **Why**: Edge Functions are not designed for this. A server can handle longer execution times, retries, and persistent connections, reducing failure rates. Mobile users get a reliable response without hanging. - **Impact**: Reliability - eliminates timeouts and partial failures. UX - prevents long waits on mobile; consider returning a job ID immediately and polling for results. 4. **Add Client-Side Caching & Request Deduplication** - **What**: Cache Edge Function responses on the device (e.g., via AsyncStorage or React Query)for read-heavy endpoints. Deduplicate identical in-flight requests. - **Why**: Reduces network round-trips, especially on slow networks. Mobile users see cached data instantly while fresh data loads in the background. - **Impact**: Latency - 50-80% reduction in perceived wait time for repeated views. Reliability - fewer requests means fewer failure points. 5. **Batch Non-Critical Updates** - **What**: Combine analytics, logging, or cache refresh calls into a single batched Edge Function request, sent periodically or on app background. - **Why**: Reduces number of Edge invocations, lowering cold start frequency and network overhead. Mobile users don't wait for these. - **Impact**: Latency - removes unnecessary blocking calls from critical paths. Cost - reduces Edge Function invocations. . --- ### ⚖️ Final Verdict - **Is this architecture mobile-appropriate?** **Partially.** The separation of concerns is sound, but the execution (heavy imports, blocking calls, orchestration in Edge)is not optimized for mobile constraints. It will work, but users will experience noticeable delays and potential failures on unstable networks. . - **Is Edge overused, underused, or correctly used?** **Overused for orchestration, underused for caching.** Edge is correctly used for auth/guard and validation, but it's being stretched into areas where it's a poor fit (heavy AI orchestration, long-running tasks).. It should be used more aggressively for caching read-heavy responses at the edge, reducing origin load. - **What is the single highest-impact improvement?** **Implement optimistic UI for all user-triggered actions.** This single change will eliminate the most visible mobile UX pain point - the perceived freeze during network requests. It doesn't require backend changes, works immediately, and directly improves user satisfaction. Combined with lazy imports in Edge Functions, this will transform the perceived performance from "slow and fragile" to "responsive and reliable".