**Role:** Act as a Principal Cloud Data Engineer and Geospatial Data Scientist.

**Task:** I have a functional but highly inefficient local Python script that analyzes and compares vegetation indices (e.g., NDVI) and terrain changes in the Valencia region before and after the recent DANA floods. My goal is to migrate this bottlenecked script into a highly scalable, distributed geospatial pipeline on AWS to process the data efficiently at high resolution.

**Requirements:**

1. **Distributed Cloud Architecture:**
   - Migrate the local sequential processing logic to a distributed AWS compute framework (e.g., Lithops, Dask or AWS Lambda) capable of handling massive geospatial arrays in parallel.
2. **Resource Optimization:**
   - Analyze the computational requirements for high-resolution raster processing and select the most optimal AWS compute resources. Think step-by-step about memory management to prevent out-of-memory (OOM) errors before executing.
3. **High-Resolution Processing:**
   - Ensure the pipeline scales to process the satellite imagery strictly at a **30 meters per pixel** resolution.
4. **Execution Protocol (MCP):**
   - Using your available tools and the Model Context Protocol (MCP), securely interface with my AWS account to provision the necessary distributed infrastructure, upload the data/logic, and execute the pipeline automatically.
5. **Scientific Tone:**
   - Explain your architectural decisions, chunking/parallelization strategy (e.g., using Lithops or Dask), and data storage formats (e.g., Cloud Optimized GeoTIFFs in S3) using terminology appropriate for senior data scientists and geospatial researchers.

**Output:**
Once the distributed execution is complete, please provide:
- The generated high-resolution (30m/px) plots/visualizations demonstrating the pre- and post-DANA landscape differences.
- A technical bulleted summary of the AWS distributed architecture deployed (Framework used, Instance types, Data flow).
- A brief analysis of the performance improvements (e.g., execution time, parallelization efficiency) compared to the single-threaded local approach.
