diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ccad55c..682d8e8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -44,13 +44,14 @@ Before you begin, ensure you have the following installed:
 
    ```json
    {
-     "test-cloud": {
-       "apiKey": "your-test-api-key",
-       "apiSecret": "your-test-api-secret",
-       "uploadPreset": "your-test-upload-preset"
+     "your-cloud-name": {
+       "apiKey": "your-api-key",
+       "apiSecret": "your-api-secret"
      }
    }
    ```
+   
+   > **Note:** The **cloud name is the key** (the property name). You can optionally add `"uploadPreset"` if you want a default preset.
 
 4. **Build the extension**
    ```bash
diff --git a/README.md b/README.md
index dc3abb4..488a0cb 100644
--- a/README.md
+++ b/README.md
@@ -40,19 +40,15 @@ Auto-created with placeholder content on first use:
 
 ```json
 {
-  "your-cloud-name-1": {
-    "apiKey": "<your-api-key>",
-    "apiSecret": "<your-api-secret>",
-    "uploadPreset": "<your-default-upload-preset>"
-  },
-  "your-cloud-name-2": {
-    "apiKey": "<your-api-key>",
-    "apiSecret": "<your-api-secret>",
-    "uploadPreset": "<your-default-upload-preset>"
+  "REPLACE_WITH_YOUR_CLOUD_NAME": {
+    "apiKey": "REPLACE_WITH_YOUR_API_KEY",
+    "apiSecret": "REPLACE_WITH_YOUR_API_SECRET"
   }
 }
 ```
 
+> **Note:** The **cloud name is the key** (the property name in the JSON object). You can optionally add `"uploadPreset": "your-preset-name"` if you want to use a default upload preset.
+
 ### 2. **Workspace Config** (Optional override)
 You can also include a project-specific config:
 ```
@@ -87,13 +83,13 @@ Once a valid configuration has been added, the active environment will be shown
 - **File Browser** – Click "Browse Files" to select files from your system
 - **Remote URL** – Paste a URL to upload from a remote source
 - **Folder Selection** – Choose the destination folder from a dropdown
-- **Upload Presets** – Select from your configured upload presets (view preset settings with the "Settings" toggle)
+- **Upload Presets** – Optionally select from your configured upload presets (signed uploads work without a preset)
 - **Custom Public ID** – Specify a custom public ID for single file uploads
 - **Tags** – Add comma-separated tags to your uploads
 - **Progress Tracking** – See real-time upload progress for each file
 - **Uploaded Assets** – View thumbnails of uploaded assets, click to preview, copy URL or public ID
 
-**Learn more**: See the [Cloudinary Upload Presets documentation](https://cloudinary.com/documentation/upload_presets) for details on creating and configuring upload presets.
+**Learn more**: See the [Cloudinary Upload Presets documentation](https://cloudinary.com/documentation/upload_presets) for details on creating and configuring upload presets (optional).
 
 ![Uploading assets](https://res.cloudinary.com/demo/video/upload/w_1200/f_auto:animated/q_auto/e_accelerate:100/e_loop/docs/vscode-extension-vid3)
 
diff --git a/package.json b/package.json
index 25641e8..f00b6a4 100644
--- a/package.json
+++ b/package.json
@@ -82,8 +82,9 @@
         "title": "  Refresh"
       },
       {
-        "command": "cloudinary.setResourceFilter",
-        "title": " Filter",
+        "command": "cloudinary.viewOptions",
+        "title": "View Options",
+        "icon": "$(filter)",
         "category": "Cloudinary"
       },
       {
@@ -104,6 +105,7 @@
       {
         "command": "cloudinary.openGlobalConfig",
         "title": "Config",
+        "icon": "$(gear)",
         "category": "Cloudinary"
       },
       {
@@ -127,17 +129,17 @@
         {
           "command": "cloudinary.searchAssets",
           "when": "view == cloudinaryMediaLibrary",
-          "group": "1_search@1"
+          "group": "navigation@3"
         },
         {
-          "command": "cloudinary.setResourceFilter",
+          "command": "cloudinary.viewOptions",
           "when": "view == cloudinaryMediaLibrary",
-          "group": "1_search@2"
+          "group": "navigation@4"
         },
         {
           "command": "cloudinary.openGlobalConfig",
           "when": "view == cloudinaryMediaLibrary",
-          "group": "2_config@1"
+          "group": "navigation@5"
         }
       ],
       "view/item/context": [
diff --git a/src/commands/loadMoreAssets.ts b/src/commands/loadMoreAssets.ts
deleted file mode 100644
index c0c57fd..0000000
--- a/src/commands/loadMoreAssets.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import * as vscode from "vscode";
-import { CloudinaryTreeDataProvider } from "../tree/treeDataProvider";
-
-/**
- * Registers the 'load more assets' command to handle pagination in the Cloudinary tree.
- * @param context - VS Code extension context.
- * @param provider - Instance of CloudinaryTreeDataProvider used to fetch and update asset nodes.
- */
-function registerLoadMore(
-  context: vscode.ExtensionContext,
-  provider: CloudinaryTreeDataProvider
-) {
-  context.subscriptions.push(
-    vscode.commands.registerCommand(
-      "cloudinary.loadMoreAssets",
-      async (folderPath: string, nextCursor: string) => {
-        if (!nextCursor) {
-          vscode.window.showErrorMessage("No more assets to load.");
-          return;
-        }
-
-        const newAssets = await provider.fetchFoldersAndAssets(
-          folderPath,
-          nextCursor,
-          true
-        );
-
-        if (newAssets.length === 0) {
-          vscode.window.showErrorMessage("No additional assets found.");
-          return;
-        }
-
-        provider.updateLoadMoreItem(folderPath, nextCursor);
-
-        provider.refresh(
-          {
-            folderPath,
-            nextCursor
-          },
-          true
-        );
-      }
-    )
-  );
-}
-
-export default registerLoadMore;
\ No newline at end of file
diff --git a/src/commands/registerCommands.ts b/src/commands/registerCommands.ts
index 0e8ec58..9a50e14 100644
--- a/src/commands/registerCommands.ts
+++ b/src/commands/registerCommands.ts
@@ -1,8 +1,7 @@
 import * as vscode from "vscode";
 import registerSearch from "./searchAssets";
-import registerFilter from "./setResourceFilter";
+import registerViewOptions from "./viewOptions";
 import registerPreview from "./previewAsset";
-import registerLoadMore from "./loadMoreAssets";
 import registerUpload from "./uploadWidget";
 import registerClipboard from "./copyCommands";
 import registerSwitchEnv from "./switchEnvironment";
@@ -34,9 +33,8 @@ function registerAllCommands(
 
   registerSearch(context, provider);
   registerClearSearch(context, provider);
-  registerFilter(context, provider);
+  registerViewOptions(context, provider);
   registerPreview(context);
-  registerLoadMore(context, provider);
   registerUpload(context, provider);
   registerClipboard(context);
   registerSwitchEnv(context, provider, statusBar);
diff --git a/src/commands/setResourceFilter.ts b/src/commands/setResourceFilter.ts
deleted file mode 100644
index a576005..0000000
--- a/src/commands/setResourceFilter.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import * as vscode from "vscode";
-import { CloudinaryTreeDataProvider } from "../tree/treeDataProvider";
-
-type ResourceType = "all" | "image" | "video" | "raw";
-
-/**
- * Registers a command to let users filter Cloudinary assets by resource type.
- * @param context - VS Code extension context.
- * @param provider - Cloudinary tree data provider instance.
- */
-function registerFilter(
-  context: vscode.ExtensionContext,
-  provider: CloudinaryTreeDataProvider
-) {
-  context.subscriptions.push(
-    vscode.commands.registerCommand(
-      "cloudinary.setResourceFilter",
-      async () => {
-        const options: ResourceType[] = ["all", "image", "video", "raw"];
-        const selected = await vscode.window.showQuickPick(options, {
-          placeHolder: "Filter Cloudinary assets by type",
-        });
-
-        if (selected) {
-          provider.refresh({ resourceTypeFilter: selected as ResourceType });
-        }
-      }
-    )
-  );
-}
-
-export default registerFilter;
diff --git a/src/commands/switchEnvironment.ts b/src/commands/switchEnvironment.ts
index c27d331..743d2f6 100644
--- a/src/commands/switchEnvironment.ts
+++ b/src/commands/switchEnvironment.ts
@@ -8,7 +8,7 @@ import { generateUserAgent } from "../utils/userAgent";
 interface CloudinaryEnvironment {
   apiKey: string;
   apiSecret: string;
-  uploadPreset: string;
+  uploadPreset?: string;  // Optional: Default upload preset
 }
 
 /**
@@ -44,7 +44,7 @@ function registerSwitchEnv(
           provider.cloudName = selected;
           provider.apiKey = env.apiKey;
           provider.apiSecret = env.apiSecret;
-          provider.uploadPreset = env.uploadPreset;
+          provider.uploadPreset = env.uploadPreset || null;
 
           const cacheKey = `cloudinary.dynamicFolders.${selected}`;
           const cachedFolderMode = context.globalState.get(cacheKey) as boolean | undefined;
@@ -68,7 +68,13 @@ function registerSwitchEnv(
             api_secret: env.apiSecret,
           });
 
-          statusBar.text = `$(cloud) ${selected}`;
+          // Update status bar with folder mode indicator
+          const folderMode = provider.dynamicFolders ? "Dynamic" : "Fixed";
+          statusBar.text = `$(cloud) ${selected} $(folder) ${folderMode}`;
+          statusBar.tooltip = provider.dynamicFolders
+            ? "Click to switch Cloudinary environment\n\nDynamic Folders: Assets can be organized independently of their public ID"
+            : "Click to switch Cloudinary environment\n\nFixed Folders: Asset folder is determined by public ID path";
+
           provider.refresh({
             folderPath: '',
             nextCursor: null,
diff --git a/src/commands/uploadWidget.ts b/src/commands/uploadWidget.ts
index 14de3e1..231ac08 100644
--- a/src/commands/uploadWidget.ts
+++ b/src/commands/uploadWidget.ts
@@ -44,14 +44,8 @@ function registerUpload(
   context.subscriptions.push(
     vscode.commands.registerCommand("cloudinary.openUploadWidget", async () => {
       try {
+        // Fetch presets but don't require them - signed uploads work without presets
         await provider.fetchUploadPresets();
-        const uploadPreset = provider.getCurrentUploadPreset();
-
-        if (!uploadPreset) {
-          vscode.window.showErrorMessage("No upload presets available. Please create one in your Cloudinary account.");
-          return;
-        }
-
         openOrRevealUploadPanel("", provider, context);
       } catch (err: any) {
         vscode.window.showErrorMessage(`Failed to open upload widget: ${err.message}`);
@@ -65,14 +59,8 @@ function registerUpload(
       "cloudinary.uploadToFolder",
       async (folderItem: { label: string; data: { path?: string } }) => {
         try {
+          // Fetch presets but don't require them - signed uploads work without presets
           await provider.fetchUploadPresets();
-          const uploadPreset = provider.getCurrentUploadPreset();
-
-          if (!uploadPreset) {
-            vscode.window.showErrorMessage("No upload presets available. Please create one in your Cloudinary account.");
-            return;
-          }
-
           const folderPath = folderItem.data.path || "";
           openOrRevealUploadPanel(folderPath, provider, context);
         } catch (err: any) {
@@ -234,12 +222,17 @@ function createUploadPanel(
     }
 
     // Get upload options based on current preset, folder, and optional overrides
-    const getUploadOptions = (presetName: string, folder: string, publicId?: string, tags?: string, fileName?: string) => {
+    // Upload preset is optional - signed uploads work without one
+    const getUploadOptions = (presetName: string | null | undefined, folder: string, publicId?: string, tags?: string, fileName?: string) => {
       const options: Record<string, any> = {
-        upload_preset: presetName,
         resource_type: "auto",
       };
 
+      // Only add upload_preset if one is selected (not null, undefined, or empty string)
+      if (presetName && presetName.trim()) {
+        options.upload_preset = presetName;
+      }
+
       // Add folder configuration
       if (folder) {
         if (provider.dynamicFolders) {
@@ -276,7 +269,8 @@ function createUploadPanel(
     };
 
     if (message.command === "uploadFile" && message.dataUri && message.fileId) {
-      const presetName = message.preset || currentPreset;
+      // Use nullish coalescing - empty string "" means "no preset" (signed upload)
+      const presetName = message.preset !== undefined ? message.preset : currentPreset;
       const folder = message.folderPath !== undefined ? message.folderPath : currentFolderPath;
       const options = getUploadOptions(presetName, folder, message.publicId, message.tags, message.fileName);
 
@@ -315,7 +309,8 @@ function createUploadPanel(
     }
 
     if (message.command === "uploadUrl" && message.url) {
-      const presetName = message.preset || currentPreset;
+      // Use nullish coalescing - empty string "" means "no preset" (signed upload)
+      const presetName = message.preset !== undefined ? message.preset : currentPreset;
       const folder = message.folderPath !== undefined ? message.folderPath : currentFolderPath;
       // Try to extract filename from URL for display_name
       let urlFileName: string | undefined;
@@ -1009,10 +1004,11 @@ function getWebviewContent(
         <!-- Preset Selector -->
         <div class="setting-group">
           <div class="preset-header">
-            <div class="setting-label">Upload Preset</div>
-            <button class="preset-details-toggle" id="presetDetailsToggle">Settings</button>
+            <div class="setting-label">Upload Preset <span style="opacity: 0.7; font-weight: normal;">(optional)</span></div>
+            ${provider.uploadPresets.length > 0 ? '<button class="preset-details-toggle" id="presetDetailsToggle">Settings</button>' : ''}
           </div>
           <select id="presetSelect">
+            <option value="">No preset (signed upload)</option>
             ${provider.uploadPresets
       .map(
         (preset) => `
@@ -1146,7 +1142,13 @@ function getWebviewContent(
        * Update preset details display
        */
       function updatePresetDetails() {
-        const preset = presets.find(p => p.name === presetSelect.value);
+        const selectedValue = presetSelect.value;
+        if (!selectedValue) {
+          // No preset selected - using signed upload
+          presetDetails.textContent = 'Using signed upload (no preset required)';
+          return;
+        }
+        const preset = presets.find(p => p.name === selectedValue);
         if (preset) {
           presetDetails.textContent = formatPresetSettings(preset.settings);
         }
@@ -1158,11 +1160,13 @@ function getWebviewContent(
       /**
        * Toggle preset details visibility
        */
-      presetDetailsToggle.addEventListener('click', () => {
-        const isVisible = presetDetails.classList.toggle('visible');
-        presetDetailsToggle.classList.toggle('expanded', isVisible);
-        presetDetailsToggle.textContent = isVisible ? 'Hide' : 'Settings';
-      });
+      if (presetDetailsToggle) {
+        presetDetailsToggle.addEventListener('click', () => {
+          const isVisible = presetDetails.classList.toggle('visible');
+          presetDetailsToggle.classList.toggle('expanded', isVisible);
+          presetDetailsToggle.textContent = isVisible ? 'Hide' : 'Settings';
+        });
+      }
 
       /**
        * Update preset details when selection changes
@@ -1185,10 +1189,10 @@ function getWebviewContent(
       }
 
       /**
-       * Get current preset
+       * Get current preset (returns null if no preset selected)
        */
       function getCurrentPreset() {
-        return presetSelect.value;
+        return presetSelect.value || null;
       }
 
       /**
diff --git a/src/commands/viewOptions.ts b/src/commands/viewOptions.ts
new file mode 100644
index 0000000..9e82f08
--- /dev/null
+++ b/src/commands/viewOptions.ts
@@ -0,0 +1,77 @@
+import * as vscode from "vscode";
+import { CloudinaryTreeDataProvider } from "../tree/treeDataProvider";
+
+type ResourceType = "all" | "image" | "video" | "raw";
+type SortDirection = "asc" | "desc";
+
+interface ViewOption {
+  label: string;
+  description?: string;
+  kind?: vscode.QuickPickItemKind;
+  action?: () => void;
+}
+
+/**
+ * Registers a command that opens a Quick Pick with view options (filter and sort).
+ * @param context - VS Code extension context.
+ * @param provider - Cloudinary tree data provider instance.
+ */
+function registerViewOptions(
+  context: vscode.ExtensionContext,
+  provider: CloudinaryTreeDataProvider
+) {
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      "cloudinary.viewOptions",
+      async () => {
+        const options: ViewOption[] = [
+          // Filter section
+          { label: "Filter by Type", kind: vscode.QuickPickItemKind.Separator },
+          {
+            label: "$(file) All Types",
+            description: "Show all asset types",
+            action: () => provider.refresh({ resourceTypeFilter: "all" as ResourceType }),
+          },
+          {
+            label: "$(file-media) Images Only",
+            description: "Show only images",
+            action: () => provider.refresh({ resourceTypeFilter: "image" as ResourceType }),
+          },
+          {
+            label: "$(device-camera-video) Videos Only",
+            description: "Show only videos",
+            action: () => provider.refresh({ resourceTypeFilter: "video" as ResourceType }),
+          },
+          {
+            label: "$(file-binary) Raw Files Only",
+            description: "Show only raw files",
+            action: () => provider.refresh({ resourceTypeFilter: "raw" as ResourceType }),
+          },
+          // Sort section
+          { label: "Sort Order", kind: vscode.QuickPickItemKind.Separator },
+          {
+            label: "$(arrow-down) Newest First",
+            description: "Most recently uploaded assets first",
+            action: () => provider.refresh({ sortDirection: "desc" as SortDirection }),
+          },
+          {
+            label: "$(arrow-up) Oldest First",
+            description: "Oldest uploaded assets first",
+            action: () => provider.refresh({ sortDirection: "asc" as SortDirection }),
+          },
+        ];
+
+        const selected = await vscode.window.showQuickPick(options, {
+          placeHolder: "Select view option",
+          matchOnDescription: true,
+        });
+
+        if (selected && selected.action) {
+          selected.action();
+        }
+      }
+    )
+  );
+}
+
+export default registerViewOptions;
diff --git a/src/commands/welcomeScreen.ts b/src/commands/welcomeScreen.ts
index b99db52..7921f38 100644
--- a/src/commands/welcomeScreen.ts
+++ b/src/commands/welcomeScreen.ts
@@ -738,23 +738,22 @@ function getWelcomeContent(provider: CloudinaryTreeDataProvider): string {
             <pre>{
   "your-cloud-name": {
     "apiKey": "your-api-key",
-    "apiSecret": "your-api-secret",
-    "uploadPreset": "your-upload-preset"
-  },
-  "staging-cloud": {
-    "apiKey": "staging-api-key",
-    "apiSecret": "staging-api-secret",
-    "uploadPreset": "staging-preset"
+    "apiSecret": "your-api-secret"
   }
 }</pre>
           </div>
 
+          <div class="info">
+            <strong>💡 Note:</strong> The <strong>cloud name is the key</strong> (the property name in the JSON, e.g., <code>"your-cloud-name"</code>). 
+            You can optionally add <code>"uploadPreset": "your-preset-name"</code> if you want to use a default upload preset.
+          </div>
+
           <h4>🔑 Finding Your Credentials</h4>
           <ol>
             <li>Go to your <span class="link" onclick="openExternal('https://console.cloudinary.com')">Cloudinary Console</span></li>
             <li>Navigate to <strong>Settings</strong> → <strong>API Keys</strong></li>
             <li>Copy your Cloud Name, API Key, and API Secret</li>
-            <li>Create an upload preset in <strong>Settings</strong> → <strong>Upload</strong></li>
+            <li>(Optional) Create an upload preset in <strong>Settings</strong> → <strong>Upload</strong> if you want to use preset-based configurations</li>
           </ol>
 
           <button class="button" onclick="openGlobalConfig()">Open Configuration File</button>
@@ -939,13 +938,7 @@ function getWelcomeContent(provider: CloudinaryTreeDataProvider): string {
         return JSON.stringify({
           "your-cloud-name": {
             "apiKey": "your-api-key",
-            "apiSecret": "your-api-secret",
-            "uploadPreset": "your-upload-preset"
-          },
-          "staging-cloud": {
-            "apiKey": "staging-api-key",
-            "apiSecret": "staging-api-secret",
-            "uploadPreset": "staging-preset"
+            "apiSecret": "your-api-secret"
           }
         }, null, 2);
       }
diff --git a/src/config/configUtils.ts b/src/config/configUtils.ts
index c47cadd..c89a988 100644
--- a/src/config/configUtils.ts
+++ b/src/config/configUtils.ts
@@ -6,7 +6,7 @@ import * as vscode from 'vscode';
 export interface CloudinaryEnvironment {
   apiKey: string;
   apiSecret: string;
-  uploadPreset: string;  // Default upload preset to use
+  uploadPreset?: string;  // Optional: Default upload preset to use (signed uploads work without it)
 }
 
 /**
@@ -23,12 +23,14 @@ export function isPlaceholderConfig(
 ): boolean {
   const placeholderPatterns = [
     'your-cloud-name',
-    '<your-api-key>',
-    '<your-api-secret>',
-    '<your-default-upload-preset>',
+    'your_cloud_name',
+    'replace_with_your_cloud_name',
     'your-api-key',
+    'your_api_key',
+    'replace_with_your_api_key',
     'your-api-secret',
-    'your-default-upload-preset',
+    'your_api_secret',
+    'replace_with_your_api_secret',
   ];
 
   const values = [cloudName, apiKey, apiSecret].filter(Boolean) as string[];
@@ -54,19 +56,16 @@ export function getGlobalConfigPath(): string {
   }
 
   if (!fs.existsSync(envPath)) {
-    const template: Record<string, CloudinaryEnvironment> = {
-      'your-cloud-name-1': {
-        apiKey: '<your-api-key>',
-        apiSecret: '<your-api-secret>',
-        uploadPreset: '<your-default-upload-preset>'  // Default preset to use
-      },
-      'your-cloud-name-2': {
-        apiKey: '<your-api-key>',
-        apiSecret: '<your-api-secret>',
-        uploadPreset: '<your-default-upload-preset>'  // Default preset to use
-      },
-    };
-    fs.writeFileSync(envPath, JSON.stringify(template, null, 2), 'utf-8');
+    // Create template with clear placeholders
+    // Note: Cloud name is the KEY (e.g., "my-cloud-name"), not a value inside the object
+    const templateContent = `{
+  "REPLACE_WITH_YOUR_CLOUD_NAME": {
+    "apiKey": "REPLACE_WITH_YOUR_API_KEY",
+    "apiSecret": "REPLACE_WITH_YOUR_API_SECRET"
+  }
+}
+`;
+    fs.writeFileSync(envPath, templateContent, 'utf-8');
 
     vscode.window.showInformationMessage(
       '✅ Created global Cloudinary config at ~/.cloudinary/environments.json'
diff --git a/src/extension.ts b/src/extension.ts
index 44b480b..9f52cab 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -14,6 +14,24 @@ import { generateUserAgent } from "./utils/userAgent";
 
 let statusBar: vscode.StatusBarItem;
 
+/**
+ * Returns the status bar text with cloud name and folder mode indicator.
+ */
+function getStatusBarText(cloudName: string, dynamicFolders: boolean): string {
+  const folderMode = dynamicFolders ? "Dynamic" : "Fixed";
+  return `$(cloud) ${cloudName} $(folder) ${folderMode}`;
+}
+
+/**
+ * Returns the status bar tooltip with folder mode explanation.
+ */
+function getStatusBarTooltip(dynamicFolders: boolean): string {
+  const modeDescription = dynamicFolders
+    ? "Dynamic Folders: Assets can be organized independently of their public ID"
+    : "Fixed Folders: Asset folder is determined by public ID path";
+  return `Click to switch Cloudinary environment\n\n${modeDescription}`;
+}
+
 /**
  * Called by VS Code on extension activation. Sets up provider, status bar, and commands.
  * @param context - Extension context provided by VS Code.
@@ -69,7 +87,7 @@ export async function activate(context: vscode.ExtensionContext) {
   cloudinaryProvider.cloudName = firstCloudName;
   cloudinaryProvider.apiKey = selectedEnv.apiKey;
   cloudinaryProvider.apiSecret = selectedEnv.apiSecret;
-  cloudinaryProvider.uploadPreset = selectedEnv.uploadPreset;
+  cloudinaryProvider.uploadPreset = selectedEnv.uploadPreset || null;
 
   // Set user platform for analytics
   (cloudinary.utils as any).userPlatform = generateUserAgent();
@@ -84,6 +102,7 @@ export async function activate(context: vscode.ExtensionContext) {
     vscode.StatusBarAlignment.Right,
     500
   );
+  // Status bar text will be updated after folder mode detection
   statusBar.text = `$(cloud) ${cloudinaryProvider.cloudName}`;
   statusBar.tooltip = "Click to switch Cloudinary environment";
   statusBar.command = "cloudinary.switchEnvironment";
@@ -128,11 +147,7 @@ export async function activate(context: vscode.ExtensionContext) {
     cloudinaryProvider.cloudName = newCloudName;
     cloudinaryProvider.apiKey = env.apiKey;
     cloudinaryProvider.apiSecret = env.apiSecret;
-    cloudinaryProvider.uploadPreset = env.uploadPreset;
-
-    statusBar.text = `$(cloud) ${newCloudName}`;
-    statusBar.tooltip = "Click to switch Cloudinary environment";
-    statusBar.command = "cloudinary.switchEnvironment";
+    cloudinaryProvider.uploadPreset = env.uploadPreset || null;
 
     // Update user platform for analytics
     (cloudinary.utils as any).userPlatform = generateUserAgent();
@@ -157,6 +172,11 @@ export async function activate(context: vscode.ExtensionContext) {
       context.globalState.update(cacheKey, cloudinaryProvider.dynamicFolders);
     }
 
+    // Update status bar with folder mode indicator
+    statusBar.text = getStatusBarText(newCloudName!, cloudinaryProvider.dynamicFolders);
+    statusBar.tooltip = getStatusBarTooltip(cloudinaryProvider.dynamicFolders);
+    statusBar.command = "cloudinary.switchEnvironment";
+
     cloudinaryProvider.refresh({
       folderPath: '',
       nextCursor: null,
@@ -182,6 +202,10 @@ export async function activate(context: vscode.ExtensionContext) {
     context.globalState.update(cacheKey, cloudinaryProvider.dynamicFolders);
   }
 
+  // Update status bar with folder mode indicator
+  statusBar.text = getStatusBarText(cloudinaryProvider.cloudName, cloudinaryProvider.dynamicFolders);
+  statusBar.tooltip = getStatusBarTooltip(cloudinaryProvider.dynamicFolders);
+
   vscode.window.registerTreeDataProvider(
     "cloudinaryMediaLibrary",
     cloudinaryProvider
diff --git a/src/tree/cloudinaryItem.ts b/src/tree/cloudinaryItem.ts
index 30eba59..5514da4 100644
--- a/src/tree/cloudinaryItem.ts
+++ b/src/tree/cloudinaryItem.ts
@@ -2,7 +2,7 @@
 import * as vscode from 'vscode';
 import { v2 as cloudinary } from 'cloudinary';
 
-export type CloudinaryItemType = 'asset' | 'folder' | 'loadMore' | 'divider' | 'clearSearch';
+export type CloudinaryItemType = 'asset' | 'folder' | 'divider' | 'clearSearch' | 'loading';
 
 interface AssetData {
   public_id: string;
@@ -18,12 +18,7 @@ interface FolderData {
   [key: string]: any;
 }
 
-interface LoadMoreData {
-  folderPath: string;
-  nextCursor: string;
-}
-
-export type ItemData = AssetData | FolderData | LoadMoreData | Record<string, unknown>;
+export type ItemData = AssetData | FolderData | Record<string, unknown>;
 
 /**
  * Represents a single item in the Cloudinary Tree View.
@@ -102,17 +97,6 @@ class CloudinaryItem extends vscode.TreeItem {
       this.iconPath = new vscode.ThemeIcon('folder');
     }
 
-    // === LOAD MORE NODE ===
-    else if (type === 'loadMore') {
-      this.contextValue = 'loadMore';
-      this.iconPath = new vscode.ThemeIcon('sync');
-      this.command = {
-        command: 'cloudinary.loadMoreAssets',
-        title: 'Load More',
-        arguments: [(data as LoadMoreData).folderPath, (data as LoadMoreData).nextCursor],
-      };
-    }
-
     // === DIVIDER NODE ===
     else if (type === 'divider') {
       this.contextValue = undefined;
@@ -129,6 +113,12 @@ class CloudinaryItem extends vscode.TreeItem {
         title: 'Clear Search',
       };
     }
+    // === LOADING INDICATOR NODE ===
+    else if (type === 'loading') {
+      this.contextValue = undefined;
+      this.iconPath = new vscode.ThemeIcon('loading~spin');
+      this.tooltip = 'Loading additional assets in the background...';
+    }
   }
 }
 
diff --git a/src/tree/treeDataProvider.ts b/src/tree/treeDataProvider.ts
index b4f4c80..844211f 100644
--- a/src/tree/treeDataProvider.ts
+++ b/src/tree/treeDataProvider.ts
@@ -24,10 +24,17 @@ export class CloudinaryTreeDataProvider implements vscode.TreeDataProvider<Cloud
     searchQuery: null as string | null,
     isPaginating: false,
     resourceTypeFilter: 'all' as 'image' | 'video' | 'raw' | 'all',
+    sortDirection: 'desc' as 'asc' | 'desc',
   };
 
   private assetMap: Map<string, CloudinaryItem[]> = new Map();
 
+  // Track folders currently being prefetched to prevent duplicate requests
+  private prefetchingFolders: Set<string> = new Set();
+
+  // Maximum assets to load per folder (to prevent endless fetching for huge folders)
+  private readonly MAX_ASSETS_PER_FOLDER = 5000;
+
   private _onDidChangeTreeData = new vscode.EventEmitter<CloudinaryItem | undefined | void>();
   readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
 
@@ -85,13 +92,24 @@ export class CloudinaryTreeDataProvider implements vscode.TreeDataProvider<Cloud
     append = false
   ): Promise<CloudinaryItem[]> {
     try {
-      const maxResults = 100;
-      const expression = folderPath ? `folder="${folderPath}"` : '';
+      const maxResults = 500;
+
+      // Build expression based on folder mode
+      // Dynamic folders: use asset_folder field to prevent duplicates
+      // Fixed folders: use folder field (or empty for root to get all, then filter)
+      let expression: string;
+      if (this.dynamicFolders) {
+        // Dynamic folders: use asset_folder to only get assets in this specific folder
+        expression = folderPath ? `asset_folder="${folderPath}"` : 'asset_folder=""';
+      } else {
+        // Fixed folders: use folder field (empty returns all, filtered below)
+        expression = folderPath ? `folder="${folderPath}"` : '';
+      }
 
       const folderPromise = cloudinary.api.sub_folders(folderPath);
       const assetQuery = cloudinary.search
         .expression(expression)
-        .sort_by('created_at', 'desc')
+        .sort_by('created_at', this.viewState.sortDirection)
         .max_results(maxResults)
         .with_field(["tags", "context", "metadata"]);
 
@@ -115,9 +133,12 @@ export class CloudinaryTreeDataProvider implements vscode.TreeDataProvider<Cloud
       );
 
       const filteredAssets = assetsResult.resources.filter((asset: any) => {
-        const isRootLoad = folderPath === '' && !this.dynamicFolders;
-        const isNestedAsset = asset.public_id.includes('/');
-        if (isRootLoad && isNestedAsset) { return false; }
+        // For fixed folders at root level, filter out nested assets (they'll appear in their folders)
+        if (!this.dynamicFolders && folderPath === '') {
+          const isNestedAsset = asset.public_id.includes('/');
+          if (isNestedAsset) { return false; }
+        }
+        // Apply resource type filter
         if (this.viewState.resourceTypeFilter === 'all') { return true; }
         return asset.resource_type?.toLowerCase() === this.viewState.resourceTypeFilter;
       });
@@ -141,19 +162,25 @@ export class CloudinaryTreeDataProvider implements vscode.TreeDataProvider<Cloud
         this.assetMap.set(folderPath, [...existing, ...newAssets]);
       }
 
-      if (assetsResult.next_cursor) {
+      // If there are more assets, start background pre-fetching
+      if (assetsResult.next_cursor && !append) {
         this.viewState.nextCursor = assetsResult.next_cursor;
-        const loadMoreItem = new CloudinaryItem(
-          'Load More...',
+
+        // Add a loading indicator while prefetching
+        const loadingItem = new CloudinaryItem(
+          'Loading more assets...',
           vscode.TreeItemCollapsibleState.None,
-          'loadMore',
-          {
-            folderPath,
-            nextCursor: assetsResult.next_cursor,
-          }
+          'loading',
+          { folderPath }
         );
-        const updatedList = this.assetMap.get(folderPath) || [];
-        this.assetMap.set(folderPath, [...updatedList, loadMoreItem]);
+        const currentList = this.assetMap.get(folderPath) || [];
+        this.assetMap.set(folderPath, [...currentList, loadingItem]);
+
+        // Start background prefetch (don't await - let it run async)
+        this.prefetchRemainingAssets(folderPath, assetsResult.next_cursor);
+      } else if (assetsResult.next_cursor && append) {
+        // Continue prefetching if this was a prefetch call with more data
+        this.viewState.nextCursor = assetsResult.next_cursor;
       } else {
         this.viewState.nextCursor = null;
       }
@@ -165,16 +192,164 @@ export class CloudinaryTreeDataProvider implements vscode.TreeDataProvider<Cloud
     }
   }
 
-  async searchAssets(query: string, nextCursor: string | null = null): Promise<CloudinaryItem[]> {
+  /**
+   * Background pre-fetches remaining assets for a folder.
+   * Runs asynchronously and updates the tree as more assets are loaded.
+   */
+  private async prefetchRemainingAssets(folderPath: string, initialCursor: string): Promise<void> {
+    // Prevent duplicate prefetching for the same folder
+    if (this.prefetchingFolders.has(folderPath)) {
+      return;
+    }
+    this.prefetchingFolders.add(folderPath);
+
     try {
-      const maxResults = 100;
+      let nextCursor: string | null = initialCursor;
+      let totalAssets = this.countAssetsInFolder(folderPath);
+
+      while (nextCursor && totalAssets < this.MAX_ASSETS_PER_FOLDER) {
+        const result = await this.fetchAssetsPage(folderPath, nextCursor);
+
+        if (result.assets.length === 0) {
+          break;
+        }
+
+        // Remove the loading indicator and append new assets
+        this.appendPrefetchedAssets(folderPath, result.assets, result.nextCursor);
+        totalAssets += result.assets.length;
+        nextCursor = result.nextCursor;
+
+        // Fire tree update to show new assets
+        this._onDidChangeTreeData.fire();
+      }
+
+      // Remove any remaining loading indicator
+      this.removeLoadingIndicator(folderPath);
+      this._onDidChangeTreeData.fire();
+    } catch (err: any) {
+      // Remove loading indicator on error
+      this.removeLoadingIndicator(folderPath);
+      this._onDidChangeTreeData.fire();
+      // Don't show error for background operations - they're non-critical
+      console.error('Background prefetch error:', err);
+    } finally {
+      this.prefetchingFolders.delete(folderPath);
+    }
+  }
+
+  /**
+   * Fetches a single page of assets for prefetching.
+   */
+  private async fetchAssetsPage(
+    folderPath: string,
+    cursor: string
+  ): Promise<{ assets: CloudinaryItem[]; nextCursor: string | null }> {
+    const maxResults = 500;
+
+    let expression: string;
+    if (this.dynamicFolders) {
+      expression = folderPath ? `asset_folder="${folderPath}"` : 'asset_folder=""';
+    } else {
+      expression = folderPath ? `folder="${folderPath}"` : '';
+    }
+
+    const assetQuery = cloudinary.search
+      .expression(expression)
+      .sort_by('created_at', this.viewState.sortDirection)
+      .max_results(maxResults)
+      .with_field(["tags", "context", "metadata"])
+      .next_cursor(cursor);
+
+    const assetsResult = await assetQuery.execute();
+
+    const filteredAssets = assetsResult.resources.filter((asset: any) => {
+      if (!this.dynamicFolders && folderPath === '') {
+        const isNestedAsset = asset.public_id.includes('/');
+        if (isNestedAsset) { return false; }
+      }
+      if (this.viewState.resourceTypeFilter === 'all') { return true; }
+      return asset.resource_type?.toLowerCase() === this.viewState.resourceTypeFilter;
+    });
+
+    const assets = filteredAssets.map(
+      (asset: any) =>
+        new CloudinaryItem(
+          asset.public_id,
+          vscode.TreeItemCollapsibleState.None,
+          'asset',
+          asset,
+          this.cloudName!,
+          this.dynamicFolders
+        )
+    );
+
+    return {
+      assets,
+      nextCursor: assetsResult.next_cursor || null,
+    };
+  }
+
+  /**
+   * Appends prefetched assets to the folder's cache.
+   */
+  private appendPrefetchedAssets(
+    folderPath: string,
+    newAssets: CloudinaryItem[],
+    hasMore: string | null
+  ): void {
+    const items = this.assetMap.get(folderPath) || [];
+
+    // Remove the loading indicator if present
+    const filteredItems = items.filter(item => item.type !== 'loading');
+
+    // Append new assets
+    const updatedItems = [...filteredItems, ...newAssets];
+
+    // Add loading indicator back if there's more to fetch
+    if (hasMore) {
+      updatedItems.push(
+        new CloudinaryItem(
+          'Loading more assets...',
+          vscode.TreeItemCollapsibleState.None,
+          'loading',
+          { folderPath }
+        )
+      );
+    }
+
+    this.assetMap.set(folderPath, updatedItems);
+  }
+
+  /**
+   * Removes the loading indicator from a folder.
+   */
+  private removeLoadingIndicator(folderPath: string): void {
+    const items = this.assetMap.get(folderPath);
+    if (!items) { return; }
+
+    const filteredItems = items.filter(item => item.type !== 'loading');
+    this.assetMap.set(folderPath, filteredItems);
+  }
+
+  /**
+   * Counts the number of assets currently loaded for a folder.
+   */
+  private countAssetsInFolder(folderPath: string): number {
+    const items = this.assetMap.get(folderPath) || [];
+    return items.filter(item => item.type === 'asset').length;
+  }
+
+  // Cache key for search results
+  private readonly SEARCH_CACHE_KEY = '__search__';
+
+  async searchAssets(query: string): Promise<CloudinaryItem[]> {
+    try {
+      const maxResults = 500;
       const searchQuery = cloudinary.search
         .expression(`${query}*`)
-        .sort_by('public_id', 'asc')
+        .sort_by('created_at', this.viewState.sortDirection)
         .max_results(maxResults);
 
-      if (nextCursor) { searchQuery.next_cursor(nextCursor); }
-
       const assetsResult = await searchQuery.execute();
 
       const assets = assetsResult.resources.map(
@@ -189,27 +364,156 @@ export class CloudinaryTreeDataProvider implements vscode.TreeDataProvider<Cloud
           )
       );
 
+      // Store in cache
+      this.assetMap.set(this.SEARCH_CACHE_KEY, assets);
+
+      // If there are more results, start background pre-fetching
       if (assetsResult.next_cursor) {
-        assets.push(
-          new CloudinaryItem(
-            'Load More...',
-            vscode.TreeItemCollapsibleState.None,
-            'loadMore',
-            {
-              searchQuery: query,
-              nextCursor: assetsResult.next_cursor,
-            }
-          )
+        // Add loading indicator
+        const loadingItem = new CloudinaryItem(
+          'Loading more results...',
+          vscode.TreeItemCollapsibleState.None,
+          'loading',
+          { query }
         );
+        this.assetMap.set(this.SEARCH_CACHE_KEY, [...assets, loadingItem]);
+
+        // Start background prefetch
+        this.prefetchSearchResults(query, assetsResult.next_cursor);
       }
 
-      return assets;
+      return this.assetMap.get(this.SEARCH_CACHE_KEY) || assets;
     } catch (err: any) {
       handleCloudinaryError('Search failed', err);
       return [];
     }
   }
 
+  /**
+   * Background pre-fetches remaining search results.
+   */
+  private async prefetchSearchResults(query: string, initialCursor: string): Promise<void> {
+    const prefetchKey = `search:${query}`;
+
+    // Prevent duplicate prefetching
+    if (this.prefetchingFolders.has(prefetchKey)) {
+      return;
+    }
+    this.prefetchingFolders.add(prefetchKey);
+
+    try {
+      let nextCursor: string | null = initialCursor;
+      let totalAssets = this.countSearchResults();
+
+      while (nextCursor && totalAssets < this.MAX_ASSETS_PER_FOLDER) {
+        const result = await this.fetchSearchPage(query, nextCursor);
+
+        if (result.assets.length === 0) {
+          break;
+        }
+
+        // Append new assets to search cache
+        this.appendSearchResults(result.assets, result.nextCursor);
+        totalAssets += result.assets.length;
+        nextCursor = result.nextCursor;
+
+        // Fire tree update
+        this._onDidChangeTreeData.fire();
+      }
+
+      // Remove loading indicator
+      this.removeSearchLoadingIndicator();
+      this._onDidChangeTreeData.fire();
+    } catch (err: any) {
+      this.removeSearchLoadingIndicator();
+      this._onDidChangeTreeData.fire();
+      console.error('Search prefetch error:', err);
+    } finally {
+      this.prefetchingFolders.delete(prefetchKey);
+    }
+  }
+
+  /**
+   * Fetches a single page of search results.
+   */
+  private async fetchSearchPage(
+    query: string,
+    cursor: string
+  ): Promise<{ assets: CloudinaryItem[]; nextCursor: string | null }> {
+    const maxResults = 500;
+
+    const searchQuery = cloudinary.search
+      .expression(`${query}*`)
+      .sort_by('created_at', this.viewState.sortDirection)
+      .max_results(maxResults)
+      .next_cursor(cursor);
+
+    const assetsResult = await searchQuery.execute();
+
+    const assets = assetsResult.resources.map(
+      (asset: any) =>
+        new CloudinaryItem(
+          asset.public_id,
+          vscode.TreeItemCollapsibleState.None,
+          'asset',
+          asset,
+          this.cloudName!,
+          this.dynamicFolders
+        )
+    );
+
+    return {
+      assets,
+      nextCursor: assetsResult.next_cursor || null,
+    };
+  }
+
+  /**
+   * Appends prefetched search results to the cache.
+   */
+  private appendSearchResults(newAssets: CloudinaryItem[], hasMore: string | null): void {
+    const items = this.assetMap.get(this.SEARCH_CACHE_KEY) || [];
+
+    // Remove loading indicator
+    const filteredItems = items.filter(item => item.type !== 'loading');
+
+    // Append new assets
+    const updatedItems = [...filteredItems, ...newAssets];
+
+    // Add loading indicator back if more to fetch
+    if (hasMore) {
+      updatedItems.push(
+        new CloudinaryItem(
+          'Loading more results...',
+          vscode.TreeItemCollapsibleState.None,
+          'loading',
+          {}
+        )
+      );
+    }
+
+    this.assetMap.set(this.SEARCH_CACHE_KEY, updatedItems);
+  }
+
+  /**
+   * Removes the loading indicator from search results.
+   */
+  private removeSearchLoadingIndicator(): void {
+    const items = this.assetMap.get(this.SEARCH_CACHE_KEY);
+    if (!items) { return; }
+
+    const filteredItems = items.filter(item => item.type !== 'loading');
+    this.assetMap.set(this.SEARCH_CACHE_KEY, filteredItems);
+  }
+
+  /**
+   * Counts the number of search results currently loaded.
+   */
+  private countSearchResults(): number {
+    const items = this.assetMap.get(this.SEARCH_CACHE_KEY) || [];
+    return items.filter(item => item.type === 'asset').length;
+  }
+
   /**
    * Fetches available upload presets from Cloudinary.
    * @returns Array of upload presets with their names and signed status.
@@ -238,42 +542,16 @@ export class CloudinaryTreeDataProvider implements vscode.TreeDataProvider<Cloud
   }
 
   /**
-   * Gets the currently selected upload preset or the first available one.
-   * @returns The selected upload preset name or null if none available.
+   * Gets the currently configured default upload preset.
+   * @returns The configured upload preset name, or null if none configured (uses signed upload).
    */
   getCurrentUploadPreset(): string | null {
+    // Only return a preset if one is explicitly configured and exists
     if (this.uploadPreset && this.uploadPresets.some(p => p.name === this.uploadPreset)) {
       return this.uploadPreset;
     }
-    return this.uploadPresets.length > 0 ? this.uploadPresets[0].name : null;
-  }
-
-  public updateLoadMoreItem(folderPath: string, nextCursor: string) {
-    const items = this.assetMap.get(folderPath);
-    if (!items) { return; }
-
-    const index = items.findIndex(
-      (item) =>
-        item.type === "loadMore" &&
-        item.data.folderPath === folderPath &&
-        item.data.nextCursor === nextCursor
-    );
-
-    if (index !== -1) {
-      const updated = [...items];
-      updated.splice(
-        index,
-        1,
-        new CloudinaryItem(
-          "──── More assets loaded ────",
-          vscode.TreeItemCollapsibleState.None,
-          "divider",
-          {}
-        )
-      );
-      this.assetMap.set(folderPath, updated);
-      this._onDidChangeTreeData.fire(); // optional, if you want immediate refresh
-    }
+    // Default to null (signed upload) when no preset is configured
+    return null;
   }
 
   /**