BACK TO SELECTED WORK
CASE STUDYFull-Stack Intelligence Platform

WebScope Pro

Website Intelligence Platform & Bounded Analysis Pipeline

ROLEFull-Stack System...
CORE STACKNext.js 14 App Router / TypeScript /...
YEAR2024
STATUSProduction
EST. READ25 MIN READ

Website intelligence and analysis platform that accepts a URL, safely fetches and analyzes the site, calculates SEO and performance signals, persists scan history, supports comparisons and monitoring, and produces structured insights.

Core Challenge: Websites expose data through diverse layers: metadata, headings, content structure, media, scripts, and crawl rules. The challenge was turning an unparsed URL into structured, persistent, and actionable website intelligence without unbounded execution or server crashes.

Next.js 14 App RouterTypeScriptAxiosCheerioPrismaPostgreSQLNextAuthTailwind CSS

Raw URLs Lack Structured Operational Intelligence

Websites expose information through many different layers: metadata, headings, content structure, media, scripts, response characteristics, and crawl rules. The challenge was to turn a raw URL into structured, persistent, and actionable website intelligence.

Scope Boundary: WebScope is engineered as a lightweight, serverless-friendly website intelligence platform for fast heuristic analysis, continuous monitoring, and automated comparisons. It does not claim to be a heavyweight headless browser replacement for Google Lighthouse, Google Search Console, or full commercial enterprise crawler suites.

KEY CONSTRAINTS & COORDINATION PROBLEMS1 VECTORS
  • ▸Scope Boundary: WebScope is engineered as a lightweight, serverless-friendly website intelligence platform for fast heuristic analysis, continuous monitoring, and automated comparisons. It does not claim to be a heavyweight headless browser replacement for Google Lighthouse, Google Search Console, or full commercial enterprise crawler suites.
SYSTEM FLOW 1
URL
 │
 ├── Crawlability          (robots.txt validation, disallowed path inspection)
 ├── Metadata              (title tags, meta descriptions, canonical headers)
 ├── Content structure     (H1/H2 hierarchy, paragraph depth, word count)
 ├── SEO signals           (image alt attributes, link ratios, heading hygiene)
 ├── Performance signals   (HTML payload size, script counts, TTFB response time)
 └── Historical changes    (snapshot persistence, comparison verdicts, monitoring)
          │
          ▼
    ACTIONABLE INSIGHT

Authoritative system flow and architecture topology spec.

HORIZONTAL SCROLL ON MOBILE ↔

A Guarded, Multi-Stage Intelligence Pipeline

Rather than issuing unbounded scraping calls, WebScope structures website analysis into a deterministic 8-stage pipeline wrapped with concurrency control, timeout safeguards, and decoupled AI fallbacks.

Queries /robots.txt before touching the page, immediately rejecting disallowed paths.

Acquires 1 of 4 slots via acquireSlot() and fetches the HTML with a 5s AbortController timeout.

Cheerio builds a lightweight in-memory AST to extract titles, descriptions, headings, body text, and images.

Evaluates title length, meta presence, single H1 hygiene, heading hierarchy, content length, and image alt tags.

Measures TTFB server response time, total HTML payload size, script tag count, and asset weight distribution.

Pre-computes a deterministic qualitative output first; attempts Gemini AI generation with a strict 6-second timeout.

Saves normalized snapshots into PostgreSQL via Prisma (ScanHistory, ScrapedData, RequestLog).

Feeds interactive UI dashboards, automated side-by-side comparisons, scheduled batch monitors, and PDF/CSV exports.

SYSTEM FLOW 2
INPUT
  │
  ▼
URL VALIDATION
  │
  ▼
ROBOTS.TXT CHECK
  │
  ▼
HTTP FETCH (Axios + 5s Timeout + AbortController)
  │
  ▼
HTML PARSING (Cheerio In-Memory DOM Extraction)
  │
  ├───────────────────────────────┐
  ▼                               ▼
SEO ANALYSIS                 PERFORMANCE
(Title, Meta, H1/H2, Alt)    (TTFB, Payload, Scripts, Images)
  │                               │
  └───────────────┬───────────────┘
                  ▼
             AI INSIGHT (Gemini API with 6s Timeout & Deterministic Fallback)
                  │
                  ▼
           PERSIST RESULTS (Prisma / PostgreSQL / Neon)
                  │
                  ▼
         DASHBOARD / HISTORY
                  │
             ┌────┴────┐
             ▼         ▼
          COMPARE   MONITOR

Authoritative system flow and architecture topology spec.

HORIZONTAL SCROLL ON MOBILE ↔

1. ROBOTS.TXT CHECK

Queries /robots.txt before touching the page, immediately rejecting disallowed paths.

2. CONCURRENCY-LIMITED HTTP FETCH

Acquires 1 of 4 slots via acquireSlot() and fetches the HTML with a 5s AbortController timeout.

3. SERVER-SIDE HTML PARSING

Cheerio builds a lightweight in-memory AST to extract titles, descriptions, headings, body text, and images.

4. DERIVE SEO METRICS

Evaluates title length, meta presence, single H1 hygiene, heading hierarchy, content length, and image alt tags.

5. DERIVE PERFORMANCE SIGNALS

Measures TTFB server response time, total HTML payload size, script tag count, and asset weight distribution.

6. AI INSIGHT WITH FALLBACK

Pre-computes a deterministic qualitative output first; attempts Gemini AI generation with a strict 6-second timeout.

7. RELATIONAL PERSISTENCE

Saves normalized snapshots into PostgreSQL via Prisma (ScanHistory, ScrapedData, RequestLog).

8. PRODUCT SURFACE EXPOSURE

Feeds interactive UI dashboards, automated side-by-side comparisons, scheduled batch monitors, and PDF/CSV exports.

System Architecture & Pipeline Topology

A unified Next.js 14 full-stack architecture coupling bounded asynchronous worker queues, in-memory HTML DOM extraction, relational snapshot persistence, and automated downstream comparison and monitoring services.

MAX_CONCURRENT_ANALYSIS = 4. Incoming analysis jobs acquire an explicit slot or wait in a FIFO queue, preventing thread starvation and target server flooding.

Axios and Cheerio execute in pure Node.js serverless runtimes with sub-100ms startup times, avoiding the 150MB+ memory footprint and cold-start latency of headless browsers.

Normalized PostgreSQL models link scans to authenticated users, request logs, automated monitoring rules, and side-by-side comparison verdicts with foreign key cascades.

SYSTEM FLOW 3
                    ┌─────────────────────────────────────────┐
                    │               WEB CLIENT                │
                    │    Next.js 14 App Router + Tailwind     │
                    └────────────────────┬────────────────────┘
                                         │
                                         ▼
                    ┌─────────────────────────────────────────┐
                    │                API LAYER                │
                    │    auth / scrape / logs / stats / scans │
                    │       compare / cron / metadata / export│
                    └────────────────────┬────────────────────┘
                                         │
                                         ▼
                    ┌─────────────────────────────────────────┐
                    │            ANALYSIS PIPELINE            │
                    │  src/lib/analyzeWebsite.ts (Slot Queue) │
                    └────────────────────┬────────────────────┘
                                         │
             ┌───────────────────────────┼───────────────────────────┐
             ▼                           ▼                           ▼
        robots.txt                  HTTP FETCH                  VALIDATION
    (checkRobotsTxt)       (Axios + 5s Timeout + Abort)        (Zod Schemas)
             │                           │
             │                           ▼
             │                    Axios + Cheerio
             │                (In-Memory HTML AST)
             │                           │
             │                 ┌─────────┴─────────┐
             │                 ▼                   ▼
             │            SEO ANALYSIS        PERFORMANCE
             │          (analyzeSeo.ts)  (analyzePerformance.ts)
             │                 │                   │
             │                 └─────────┬─────────┘
             │                           ▼
             │                     AI / FALLBACK
             │              (generateAnimalSpirit + Fallback)
             │                           │
             └───────────────────────────┤
                                         ▼
                    ┌─────────────────────────────────────────┐
                    │            PRISMA / POSTGRES            │
                    │                                         │
                    │  User               RequestLog          │
                    │  ScanHistory        Monitor             │
                    │  ScrapedData        Alert               │
                    │  PageMetadata       Comparison          │
                    └────────────────────┬────────────────────┘
                                         │
              ┌──────────────────────────┼──────────────────────────┐
              ▼                          ▼                          ▼
          DASHBOARD                   COMPARE                    MONITOR
      (Overview & KPIs)         (compareService.ts)        (monitorService.ts)
              │                                                     │
              ▼                                                     ▼
        INSIGHTS / UI                                             ALERTS
  (PDF / CSV / JSON Export)                               (Threshold Violations)

Authoritative system flow and architecture topology spec.

HORIZONTAL SCROLL ON MOBILE ↔
SYSTEM SUBSYSTEMS & RESPONSIBILITIES3 SUBSYSTEMS SPECIFIED
01BOUNDED WORKER SLOTS

MAX_CONCURRENT_ANALYSIS = 4. Incoming analysis jobs acquire an explicit slot or wait in a FIFO queue, preventing thread starvation and target server flooding.

02LIGHTWEIGHT EXTRACTION

Axios and Cheerio execute in pure Node.js serverless runtimes with sub-100ms startup times, avoiding the 150MB+ memory footprint and cold-start latency of headless browsers.

03RELATIONAL SNAPSHOTS

Normalized PostgreSQL models link scans to authenticated users, request logs, automated monitoring rules, and side-by-side comparison verdicts with foreign key cascades.

End-to-End Extraction & Scoring Lifecycle

From user submission to persistent dashboard reporting, data transitions through a series of strict validation, extraction, scoring, and persistence steps.

User Submission: User enters target URL via web form or triggers scheduled monitoring batch.

API Validation: Next.js API route validates format, protocol, and sanitization rules with Zod.

Robots Check: Parser verifies target site robots.txt crawl permissions before opening socket connections.

HTTP Fetch: Axios retrieves target HTML within a 5-second AbortController timeout window.

DOM Extraction: Cheerio builds in-memory AST and parses title, meta, headings, text, media, and scripts.

Analysis Engines: SEO and performance analyzers calculate weighted scores and identify optimization gaps.

AI Interpretation: Gemini AI produces qualitative archetypes with pre-computed fallback guarantees.

Database & UI: Prisma persists the full snapshot to PostgreSQL, immediately updating user dashboards and monitors.

SYSTEM FLOW 4
USER
 │
 │ submit URL
 ▼
API
 │
 │ validate input
 ▼
ROBOTS CHECK
 │
 │ allowed
 ▼
SCRAPER
 │
 │ HTTP response
 ▼
CHEERIO PARSER
 │
 ├── title
 ├── meta description
 ├── H1 / H2
 ├── body text
 ├── images
 ├── scripts
 ├── content size
 └── response time
          │
          ▼
     ANALYSIS ENGINE
       │       │
       │       └── performance
       │
       └────────── SEO
          │
          ▼
      AI INSIGHT (with deterministic fallback)
          │
          ▼
       DATABASE (PostgreSQL / Prisma)
          │
          ▼
      DASHBOARD

Authoritative system flow and architecture topology spec.

HORIZONTAL SCROLL ON MOBILE ↔
01

User Submission:

User enters target URL via web form or triggers scheduled monitoring batch.

02

API Validation:

Next.js API route validates format, protocol, and sanitization rules with Zod.

03

Robots Check:

Parser verifies target site robots.txt crawl permissions before opening socket connections.

04

HTTP Fetch:

Axios retrieves target HTML within a 5-second AbortController timeout window.

05

DOM Extraction:

Cheerio builds in-memory AST and parses title, meta, headings, text, media, and scripts.

06

Analysis Engines:

SEO and performance analyzers calculate weighted scores and identify optimization gaps.

07

AI Interpretation:

Gemini AI produces qualitative archetypes with pre-computed fallback guarantees.

08

Database & UI:

Prisma persists the full snapshot to PostgreSQL, immediately updating user dashboards and monitors.

Navigating Unreliable External Targets & Asynchronous Failures

Operating an automated website intelligence crawler requires handling slow hosts, external rate limits, third-party AI timeouts, and multi-tenant persistence.

01 CHALLENGE

SAFE WEBSITE ANALYSIS

CHALLENGE 01
PROBLEM

External websites are inherently unreliable. Remote targets can hang indefinitely, enter infinite redirect loops, drop connections abruptly, or explicitly disallow automated crawling via robots.txt.

02 CHALLENGE

BOUNDED ANALYSIS CONCURRENCY

CHALLENGE 02
PROBLEM

Multiple users and automated monitoring batches trigger URL scans simultaneously. Unbounded concurrent operations risk socket exhaustion, Vercel serverless function throttling, and remote IP bans.

03 CHALLENGE

AI DEPENDENCY FAILURE

CHALLENGE 03
PROBLEM

Third-party LLM APIs suffer rate limits, unpredictable latency, and outages. Qualitative AI synthesis cannot become a hard blocking dependency that halts the underlying deterministic SEO and performance analysis.

04 CHALLENGE

PERSISTENT ANALYSIS HISTORY

CHALLENGE 04
PROBLEM

Analysis snapshots must remain relational and queryable across user accounts, longitudinal monitoring alerts, side-by-side domain comparisons, and export formats without data inconsistency.

Architectural Controls & Implementation Guardrails

Rather than relying on unconstrained scripts or optimistic client assumptions, WebScope enforces clear operational boundaries across concurrency, timeouts, validation, and data resilience.

CONTROL DOMAINIMPLEMENTED MECHANISMENGINEERING SPECIFICATION
CONCURRENCYBounded analysis slotsMAX_CONCURRENT_ANALYSIS = 4 via acquireSlot / releaseSlot queue
TIMEOUTSDual timeout barriers5000ms scrape timeout (AbortController) + 6000ms AI timeout
ROBOTSCrawl permission checkrobots.txt checked before firing scraping requests
VALIDATIONRuntime schema validationZod schemas guarding API routes and URL format inputs
AUTHSession managementNextAuth credentials provider with signed JWT sessions
PASSWORD SECURITYOne-way key stretchingbcrypt salt hashing before database persistence
DATABASERelational modelingPostgreSQL (Neon) with Prisma ORM migrations and indexed foreign keys
ERROR HANDLINGTyped error classificationTIMEOUT, NETWORK, DISALLOWED_BY_ROBOTS, and UNKNOWN categories
AI RESILIENCEDecoupled fallback layerDeterministic heuristic output generated first; swapped only if AI resolves
PERSISTENCELongitudinal telemetryPersistent scan history, threshold-based monitoring, and alert logs

Direct Problem-Solution-Outcome Records

Examining how key operational constraints were addressed within the WebScope codebase.

01 CHALLENGE

— UNRELIABLE EXTERNAL TARGETS

PROBLEM

A remote website may be slow, enter infinite redirects, or be unreachable.

SOLUTION

Bound requests with 5-second AbortController timeout protection and classify failures into meaningful error categories (TIMEOUT, NETWORK, DISALLOWED_BY_ROBOTS, UNKNOWN).

RESULT

The analysis pipeline fails predictably instead of hanging indefinitely or exhausting server sockets.

02 CHALLENGE

— ANALYSIS CONCURRENCY

PROBLEM

Multiple URL analyses can run simultaneously across interactive users and batch cron jobs.

SOLUTION

Implement an in-memory bounded analysis queue with a strict maximum of four active parallel analyses (MAX_CONCURRENT_ANALYSIS = 4).

RESULT

Concurrent analysis work is explicitly controlled, preventing serverless function throttling and target server bans.

03 CHALLENGE

— ROBOTS COMPLIANCE

PROBLEM

Not every target website permits automated crawling or indexation.

SOLUTION

Fetch and parse target robots.txt prior to scraping; immediately abort and return a classified error if path or agent is restricted.

RESULT

Disallowed targets are rejected cleanly before scraping execution begins, respecting target webmaster rules.

04 CHALLENGE

— AI FAILURE

PROBLEM

The AI insight layer can encounter rate limits, model outages, or slow generation times.

SOLUTION

Generate a deterministic fallback insight locally first and attempt AI generation with a strict 6-second timeout, falling back on error.

RESULT

The core SEO, performance, and comparison pipeline remains 100% functional without hard dependency on external AI services.

Architectural Decisions & Tradeoff Log

Engineering choices grounded in operational simplicity, serverless runtime constraints, and decoupled resilience.

DECISION 01 • ARCHITECTURAL DECISION

AXIOS + CHEERIO

WHY / RATIONALE

Lightweight HTTP fetching and fast, low-overhead server-side HTML parsing.

TRADE-OFF ACCEPTED

Client-rendered SPA content that only materializes after heavy JavaScript browser execution is not equivalent to a full browser-rendered crawl.

OUTCOME / IMPACT

Lightweight HTTP fetching and fast, low-overhead server-side HTML parsing.Client-rendered SPA content that only materializes after heavy JavaScript browser execution is not equivalent to a full browser-rendered crawl.

DECISION 02 • ARCHITECTURAL DECISION

PRISMA + POSTGRESQL (NEON)

WHY / RATIONALE

Relational data naturally models users, multi-page scan histories, request logs, threshold monitors, and comparison sets.

TRADE-OFF ACCEPTED

Requires declarative schema migrations and strict relational index design across foreign keys.

OUTCOME / IMPACT

Relational data naturally models users, multi-page scan histories, request logs, threshold monitors, and comparison sets.Requires declarative schema migrations and strict relational index design across foreign keys.

DECISION 03 • ARCHITECTURAL DECISION

BOUNDED CONCURRENCY (MAX 4)

WHY / RATIONALE

URL analysis is network-bound, external, and unpredictable.

TRADE-OFF ACCEPTED

Excess parallel requests wait in a brief FIFO queue during high burst periods.

OUTCOME / IMPACT

URL analysis is network-bound, external, and unpredictable.Excess parallel requests wait in a brief FIFO queue during high burst periods.

DECISION 04 • ARCHITECTURAL DECISION

AI + DETERMINISTIC FALLBACK

WHY / RATIONALE

Generative AI enriches the qualitative interpretation of raw numbers with persona archetypes.

TRADE-OFF ACCEPTED

Requires maintaining a dual-path code pipeline that derives local heuristics before calling LLM APIs.

OUTCOME / IMPACT

Generative AI enriches the qualitative interpretation of raw numbers with persona archetypes.Requires maintaining a dual-path code pipeline that derives local heuristics before calling LLM APIs.

DECISION 05 • ARCHITECTURAL DECISION

NEXT.JS 14 APP ROUTER

WHY / RATIONALE

Unified full-stack architecture combining React Server Components and route handlers.

TRADE-OFF ACCEPTED

Couples frontend dashboard deployments with API gateway lifecycles.

OUTCOME / IMPACT

Unified full-stack architecture combining React Server Components and route handlers.Couples frontend dashboard deployments with API gateway lifecycles.

State Machine & Asynchronous Failure Boundaries

Robust system design accounts for every branch in the execution graph. WebScope defines explicit transition paths for successful extractions, robots rejections, network dropouts, and AI timeouts.

PRIMARY FLOW
                URL SUBMITTED
                     │
                     ▼
                VALIDATING (Zod schema)
                     │
                     ▼
              ROBOTS CHECK
                /        \
          DISALLOWED     ALLOWED
              │             │
              ▼             ▼
            REJECT        FETCHING (Axios + 5s Abort)
                            │
                            ▼
                         PARSING (Cheerio AST)
                            │
                            ▼
                         ANALYZING
                       /     |      \
                      /      |       \
                   SEO   PERFORMANCE  AI
                      \      |       /
                       \     |      /
                            ▼
                         SAVING (PostgreSQL / Prisma)
                            │
                            ▼
                        COMPLETED

Authoritative system flow and architecture topology spec.

HORIZONTAL SCROLL ON MOBILE ↔
HANDLERS
FETCHING
   │
   ├── TIMEOUT (>5000ms)
   │     └─► AbortController triggers
   │         Returns statusCode: 0, "TIMEOUT"
   │
   ├── NETWORK ERROR
   │     └─► DNS / Socket / Connect failure
   │         Returns "NETWORK" classification
   │
   └── UNKNOWN ERROR
         └─► Fallback error wrapping

AI GENERATION
   │
   └── TIMEOUT (>6000ms) / RATE LIMIT / 500
           │
           ▼
       DETERMINISTIC FALLBACK
       (Locally computed archetype
        derived from SEO & Speed scores;
        Pipeline returns ok: true)

Authoritative system flow and architecture topology spec.

HORIZONTAL SCROLL ON MOBILE ↔

Relational Database Architecture (Prisma + PostgreSQL)

Rather than storing raw unindexed blobs, WebScope models scans, audits, monitors, and comparisons as structured relational entities in PostgreSQL.

Tenant identity & authentication owner

Immutable website scan record with scoring snapshot

Parsed DOM content & extracted technical attributes

Granular structural inspection & accessibility breakdown

Continuous domain health tracking configuration

Threshold breach event & resolution state

Side-by-side performance & SEO competitive analysis

HTTP audit log for monitoring queue seed and rate checks

SYSTEM FLOW 7
                     USER
                       │
        ┌──────────────┼───────────────┐
        │              │               │
        ▼              ▼               ▼
  SCAN HISTORY      MONITORS       COMPARISONS
        │              │
        ▼              ▼
   SCRAPED DATA      ALERTS
        │
        ▼
  PAGE METADATA

Authoritative system flow and architecture topology spec.

HORIZONTAL SCROLL ON MOBILE ↔
SYSTEM SUBSYSTEMS & RESPONSIBILITIES8 SUBSYSTEMS SPECIFIED
01User

Tenant identity & authentication owner

02ScanHistory

Immutable website scan record with scoring snapshot

03ScrapedData

Parsed DOM content & extracted technical attributes

04PageMetadata

Granular structural inspection & accessibility breakdown

05Monitor

Continuous domain health tracking configuration

06Alert

Threshold breach event & resolution state

07Comparison

Side-by-side performance & SEO competitive analysis

08RequestLog

HTTP audit log for monitoring queue seed and rate checks

Implementation Constraints & Verified Capabilities

These metrics represent verified architectural constraints enforced directly in source code, rather than synthetic marketing benchmarks.

4
MAX CONCURRENT ANALYSES

Explicit bounded queue slots in analyzeWebsite.ts preventing worker exhaustion.

5s
SCRAPE TIMEOUT

Hard AbortController cancellation ceiling on all remote Axios HTTP requests.

6s
AI TIMEOUT

Maximum time permitted for LLM generation before falling back to local heuristics.

5
MAX REDIRECT LIMIT

Strict limit on HTTP redirect follow-throughs to eliminate infinite crawl loops.

24
MAX MONITOR URLS

Upper bound on unique URLs processed in a single automated monitoring sweep.

3
DEFAULT MONITOR BATCH SIZE

Chunk size for parallel analysis in monitorService.ts to manage memory load.

What This Project Demonstrates

Engineering depth is proven through architectural discipline, failure awareness, and data modeling.

Not just a frontend dashboard. The product connects UI, API route handlers, HTTP scraping, analytical scoring engines, relational persistence, and automated background-style monitoring sweeps into one cohesive platform.

Dual timeout barriers, robots.txt restriction checks, deterministic AI fallbacks, and typed error classification are designed directly into the core execution path, ensuring resilience when external targets fail.

Scans do not evaporate in client memory. Every analysis becomes structured relational data in PostgreSQL that can be revisited, exported to PDF/CSV, compared against competitors, or tracked for performance regressions.

A clear progression of value: Raw HTML payload → structured metrics extraction → weighted scoring → qualitative persona interpretation → historical trend insights.

TAKEAWAY 01

FULL-STACK SYSTEM DESIGN

Not just a frontend dashboard. The product connects UI, API route handlers, HTTP scraping, analytical scoring engines, relational persistence, and automated background-style monitoring sweeps into one cohesive platform.

TAKEAWAY 02

FAILURE-AWARE ENGINEERING

Dual timeout barriers, robots.txt restriction checks, deterministic AI fallbacks, and typed error classification are designed directly into the core execution path, ensuring resilience when external targets fail.

TAKEAWAY 03

DATA-CENTRIC PRODUCT DESIGN

Scans do not evaporate in client memory. Every analysis becomes structured relational data in PostgreSQL that can be revisited, exported to PDF/CSV, compared against competitors, or tracked for performance regressions.

TAKEAWAY 04

PROGRESSIVE ANALYSIS

A clear progression of value: Raw HTML payload → structured metrics extraction → weighted scoring → qualitative persona interpretation → historical trend insights.

The Full Value Trajectory

From unparsed remote HTTP streams to persistent operational intelligence.

SYSTEM FLOW 8
RAW URL
   ↓
SAFE FETCH (robots.txt + timeout bounds)
   ↓
STRUCTURED EXTRACTION (Cheerio in-memory DOM AST)
   ↓
SEO + PERFORMANCE (weighted signals & heuristics)
   ↓
AI / FALLBACK (resilient qualitative interpretation)
   ↓
PERSISTENT DATA (PostgreSQL / Prisma relational models)
   ↓
COMPARE / MONITOR (longitudinal batches & alerts)
   ↓
ACTIONABLE INSIGHT

Authoritative system flow and architecture topology spec.

HORIZONTAL SCROLL ON MOBILE ↔
NEXT PRODUCTION SYSTEM • CASE STUDY

Subscription Tracker

API Architecture, Upstash Workflow Scheduling & Arcjet Security

EXPLORE SYSTEM
BACK TO SELECTED WORKENGINEERING DOSSIER • TUSHAR KANTI DEY