diff --git a/.gitignore b/.gitignore
index 02959661..ea68acdb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -42,4 +42,6 @@ test_token_ui.py
 .coverage
 coverage.xml
 pytest-report.xml
-.pytest_cache/
\ No newline at end of file
+.pytest_cache/
+
+config.json
diff --git a/.tokens.json b/.tokens.json
new file mode 100644
index 00000000..eee57b21
--- /dev/null
+++ b/.tokens.json
@@ -0,0 +1 @@
+{"vercel": "WffVzxzz3EPYaWi9biK2334y"}
\ No newline at end of file
diff --git a/core/token_manager.py b/core/token_manager.py
index e836e26d..6297c8c8 100644
--- a/core/token_manager.py
+++ b/core/token_manager.py
@@ -1,104 +1,65 @@
 import os
 from cryptography.fernet import Fernet
 
-# Constants for file paths
+# Paths
 KEY_FILE = "secret.key"
-TOKEN_FILE = "token.enc"
+TOKEN_FILE = "tokens.enc"
 
-# Constants for error messages
-ERROR_NO_TOKEN = "No GitHub token found"
-ERROR_INVALID_TOKEN = "Invalid GitHub token"
-ERROR_ENCRYPTION = "Error encrypting token"
-ERROR_DECRYPTION = "Error decrypting token"
-
-# Constants for success messages
-SUCCESS_TOKEN_SAVED = "GitHub token saved successfully"
-SUCCESS_TOKEN_DELETED = "GitHub token deleted successfully"
+# Service constants
+NETLIFY_SERVICE = "netlify"
+VERCEL_SERVICE = "vercel"
 
+# -------------------- Key Handling --------------------
 def generate_key():
     key = Fernet.generate_key()
     with open(KEY_FILE, "wb") as f:
         f.write(key)
-    print("✅ Generated new encryption key")
     return key
 
 def load_key():
     if not os.path.exists(KEY_FILE):
-        print("ℹ️ No encryption key found, generating new one")
         return generate_key()
     return open(KEY_FILE, "rb").read()
-    
-def token_exists():
-    """Check if a token file exists
-    
-    Returns:
-        bool: True if token file exists, False otherwise
-    """
-    return os.path.exists(TOKEN_FILE)
 
-def encrypt_token(token: str):
-    """Encrypt the token using the key
-    
-    Args:
-        token (str): GitHub Personal Access Token to encrypt
-        
-    Returns:
-        bool: True if successful, False otherwise
-    """
-    if not token or not isinstance(token, str) or token.strip() == "":
-        print("❌ Invalid token provided")
-        return False
-        
+# -------------------- Token Handling --------------------
+def _load_tokens():
+    """Decrypt and return stored tokens dict"""
+    if not os.path.exists(TOKEN_FILE):
+        return {}
     try:
         key = load_key()
-        encoded_token = token.encode()
         f = Fernet(key)
-        encrypted_token = f.encrypt(encoded_token)
+        with open(TOKEN_FILE, "rb") as f_enc:
+            decrypted = f.decrypt(f_enc.read())
+        return eval(decrypted.decode())
+    except Exception:
+        return {}
 
-        with open(TOKEN_FILE, "wb") as token_file:
-            token_file.write(encrypted_token)
-            
-        print("✅ Token encrypted and saved successfully")
-        return True
-    except Exception as e:
-        print(f"❌ Error encrypting token: {e}")
-        return False
-
-def decrypt_token():
-    """Decrypt the token using the key
-    
-    Returns:
-        str or None: Decrypted token if successful, None otherwise
-    """
+def _save_tokens(tokens: dict):
+    """Encrypt and save tokens dict"""
     try:
-        if not token_exists():
-            print("ℹ️ No token file found")
-            return None
-
         key = load_key()
-        with open(TOKEN_FILE, "rb") as token_file:
-            encrypted_token = token_file.read()
-
         f = Fernet(key)
-        decrypted_token = f.decrypt(encrypted_token)
-        return decrypted_token.decode()
-    except Exception as e:
-        print(f"❌ Error decrypting token: {e}")
-        return None
-        
-def clear_token():
-    """Delete the stored token file
-    
-    Returns:
-        bool: True if successful or if file didn't exist, False on error
-    """
-    try:
-        if token_exists():
-            os.remove(TOKEN_FILE)
-            print("✅ Token file deleted successfully")
-        else:
-            print("ℹ️ No token file to delete")
+        encrypted = f.encrypt(str(tokens).encode())
+        with open(TOKEN_FILE, "wb") as f_enc:
+            f_enc.write(encrypted)
         return True
     except Exception as e:
-        print(f"❌ Error deleting token file: {e}")
+        print(f"❌ Error saving tokens: {e}")
         return False
+
+def save_token(service: str, token: str):
+    tokens = _load_tokens()
+    tokens[service] = token
+    return _save_tokens(tokens)
+
+def get_token(service: str):
+    tokens = _load_tokens()
+    return tokens.get(service)
+
+def clear_token(service: str):
+    tokens = _load_tokens()
+    if service in tokens:
+        del tokens[service]
+        return _save_tokens(tokens)
+    return True
diff --git a/deploy.py b/deploy.py
new file mode 100644
index 00000000..437c57ee
--- /dev/null
+++ b/deploy.py
@@ -0,0 +1,12 @@
+from exporters.deploy_vercel import deploy_vercel
+from exporters.deploy_netlify import deploy_netlify
+
+
+if __name__ == "__main__":
+    choice = input("Deploy to (vercel/netlify): ").strip().lower()
+    if choice == "vercel":
+        deploy_vercel()
+    elif choice == "netlify":
+        deploy_netlify()
+    else:
+        print("❌ Unknown choice. Use 'vercel' or 'netlify'.")
diff --git a/deployers/netlify_deployer.py b/deployers/netlify_deployer.py
new file mode 100644
index 00000000..25b93201
--- /dev/null
+++ b/deployers/netlify_deployer.py
@@ -0,0 +1,30 @@
+import requests
+import json
+from core.token_manager import get_token, NETLIFY_SERVICE
+
+def deploy_netlify(code):
+    token = get_token(NETLIFY_SERVICE)
+    if not token:
+        return False, "❌ No Netlify token found. Please save it first."
+
+    url = "https://api.netlify.com/api/v1/sites"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "name": "karbon-generated-site",
+        "files": {
+            "index.html": code
+        }
+    }
+
+    try:
+        response = requests.post(url, headers=headers, data=json.dumps(payload))
+        if response.status_code in (200, 201):
+            return True, "✅ Deployed successfully on Netlify!"
+        else:
+            return False, f"❌ Deployment failed: {response.status_code} - {response.text}"
+    except Exception as e:
+        return False, f"❌ Error: {str(e)}"
diff --git a/exporters/deploy_netlify.py b/exporters/deploy_netlify.py
new file mode 100644
index 00000000..0a73cca3
--- /dev/null
+++ b/exporters/deploy_netlify.py
@@ -0,0 +1,34 @@
+import requests
+import json
+from core.token_manager import get_token, NETLIFY_SERVICE
+
+def deploy_netlify(code):
+    token = get_token(NETLIFY_SERVICE)
+    if not token:
+        return False, "❌ No Netlify token found. Please save it first."
+
+    url = "https://api.netlify.com/api/v1/sites"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/zip"
+    }
+
+    # For Netlify, we need to upload a ZIP of the site contents.
+    import io, zipfile
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w") as zf:
+        zf.writestr("index.html", code)
+    zip_buffer.seek(0)
+
+    files = {
+        "file": ("site.zip", zip_buffer, "application/zip")
+    }
+
+    response = requests.post(url, headers={"Authorization": f"Bearer {token}"}, files=files)
+
+    if response.status_code in (200, 201):
+        site_data = response.json()
+        site_url = site_data.get("url", "Unknown URL")
+        return True, f"✅ Deployed successfully on Netlify! 🌐 {site_url}"
+    else:
+        return False, f"❌ Deployment failed: {response.status_code} - {response.text}"
diff --git a/exporters/deploy_vercel.py b/exporters/deploy_vercel.py
new file mode 100644
index 00000000..32a2a8ce
--- /dev/null
+++ b/exporters/deploy_vercel.py
@@ -0,0 +1,33 @@
+import requests
+import json
+from core.token_manager import get_token, VERCEL_SERVICE
+
+def deploy_vercel(code):
+    token = get_token(VERCEL_SERVICE)
+    if not token:
+        return False, "❌ No Vercel token found. Please save it first."
+
+    url = "https://api.vercel.com/v13/deployments"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "name": "karbon-generated-site",
+        "files": [
+            {
+                "file": "index.html",
+                "data": code
+            }
+        ],
+        "target": "production"
+    }
+
+    response = requests.post(url, headers=headers, data=json.dumps(payload))
+
+    if response.status_code in (200, 201):
+        return True, "✅ Deployed successfully on Vercel!"
+    else:
+        return False, f"❌ Deployment failed: {response.status_code} - {response.text}"
+
diff --git a/exporters/exporter.py b/exporters/exporter.py
index 2d7afa13..31f78c41 100644
--- a/exporters/exporter.py
+++ b/exporters/exporter.py
@@ -3,38 +3,23 @@
 from datetime import datetime
 from tkinter import filedialog
 
-from github import Github
-from core.token_manager import decrypt_token
+from core.token_manager import get_token, NETLIFY_SERVICE, VERCEL_SERVICE
 
 
-def validate_github_token(token=None):
-    """Validate a GitHub token by attempting to get the user information
+def export_code(code: str, as_zip: bool = False):
+    """
+    Export generated code locally as HTML or ZIP.
 
     Args:
-        token (str, optional): The token to validate. If None, will attempt to decrypt stored token.
+        code (str): The generated HTML code.
+        as_zip (bool): If True, export as ZIP. Otherwise, export as index.html.
 
     Returns:
-        tuple: (is_valid, username, error_message)
+        str: Path to the exported file/folder, or None if cancelled.
     """
-    if token is None:
-        token = decrypt_token()
-
-    if not token:
-        return False, None, "No token provided or stored"
-
-    try:
-        g = Github(token)
-        user = g.get_user()
-        username = user.login
-        return True, username, None
-    except Exception as e:
-        return False, None, str(e)
-
-
-def export_code(code: str, as_zip: bool = False):
     folder_selected = filedialog.askdirectory(title="Select Export Folder")
     if not folder_selected:
-        return
+        return None
 
     if as_zip:
         export_name = f"karbon_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
@@ -43,58 +28,12 @@ def export_code(code: str, as_zip: bool = False):
         with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
             zipf.writestr("index.html", code)
 
-        print(f"✅ Code exported as zip: {zip_path}")
+        print(f"✅ Code exported as ZIP: {zip_path}")
+        return zip_path
     else:
         html_path = os.path.join(folder_selected, "index.html")
         with open(html_path, "w", encoding="utf-8") as f:
             f.write(code)
-        print(f"✅ Code exported as HTML: {html_path}")
-
-    return folder_selected
-
-
-def export_to_github(code: str, repo_name="karbon-export-demo"):
-    print("🚀 export_to_github() called")
-
-    # Validate GitHub token
-    is_valid, username, error = validate_github_token()
-    if not is_valid:
-        print(f"❌ GitHub token validation failed: {error}")
-        return None
-
-    print(f"✅ Using GitHub token for user: {username}")
-
-    try:
-        # Get GitHub instance and user
-        token = decrypt_token()
-        g = Github(token)
-        user = g.get_user()
-
-        # Check if repo exists, create if not
-        try:
-            print(f"🔍 Looking for existing repository: {repo_name}")
-            repo = user.get_repo(repo_name)
-            print(f"✅ Found existing repository: {repo.html_url}")
-        except Exception as repo_error:
-            print(f"ℹ️ Repository not found, creating new one: {repo_name}")
-            repo = user.create_repo(repo_name, description="Created with Karbon AI Web Builder")
-            print(f"✅ Created new repository: {repo.html_url}")
-
-        # Check if file exists, update or create
-        try:
-            print("🔍 Checking if index.html exists in repository")
-            contents = repo.get_contents("index.html")
-            print("✅ Found existing index.html, updating")
-            repo.update_file("index.html", "Update index.html via Karbon", code, contents.sha)
-            print("✅ Updated index.html in repository")
-        except Exception as file_error:
-            print("ℹ️ index.html not found, creating new file")
-            repo.create_file("index.html", "Initial commit via Karbon", code)
-            print("✅ Created index.html in repository")
-
-        print("✅ Code successfully pushed to GitHub.")
-        return repo.html_url
-    except Exception as e:
-        print(f"❌ GitHub export failed: {e}")
-        return None
 
+        print(f"✅ Code exported as HTML: {html_path}")
+        return html_path
diff --git a/exporters/repo_pusher.py b/exporters/repo_pusher.py
index 633ea758..80f9bd56 100644
--- a/exporters/repo_pusher.py
+++ b/exporters/repo_pusher.py
@@ -1,60 +1,60 @@
-import os
-from git import Repo
-from core.token_manager import decrypt_token
-from github import Github
-from exporters.exporter import validate_github_token
+# import os
+# from git import Repo
+# from core.token_manager import decrypt_token
+# from github import Github
+# from exporters.exporter import validate_github_token
 
-def push_to_github(repo_dir, repo_name):
-    """Push code to GitHub repository
+# def push_to_github(repo_dir, repo_name):
+#     """Push code to GitHub repository
     
-    Args:
-        repo_dir (str): Local directory containing the code
-        repo_name (str): Name of the GitHub repository
+#     Args:
+#         repo_dir (str): Local directory containing the code
+#         repo_name (str): Name of the GitHub repository
         
-    Returns:
-        bool: True if successful, False otherwise
-    """
-    # Validate GitHub token first
-    is_valid, username, error = validate_github_token()
-    if not is_valid:
-        print(f"❌ GitHub token validation failed: {error}")
-        return False
+#     Returns:
+#         bool: True if successful, False otherwise
+#     """
+#     # Validate GitHub token first
+#     is_valid, username, error = validate_github_token()
+#     if not is_valid:
+#         print(f"❌ GitHub token validation failed: {error}")
+#         return False
         
-    print(f"✅ Using GitHub token for user: {username}")
-    token = decrypt_token()
+#     print(f"✅ Using GitHub token for user: {username}")
+#     token = decrypt_token()
 
-    if not token:
-        print("❌ GitHub token not found.")
-        return False
+#     if not token:
+#         print("❌ GitHub token not found.")
+#         return False
 
-    remote_url = f"https://{username}:{token}@github.com/{username}/{repo_name}.git"
+#     remote_url = f"https://{username}:{token}@github.com/{username}/{repo_name}.git"
 
-    try:
-        print(f"🔍 Checking repository directory: {repo_dir}")
-        if not os.path.exists(os.path.join(repo_dir, ".git")):
-            print("ℹ️ Initializing new Git repository")
-            repo = Repo.init(repo_dir)
-            repo.git.add(A=True)
-            repo.index.commit("Initial commit from Karbon")
-            print(f"ℹ️ Adding remote: {username}/{repo_name}")
-            origin = repo.create_remote('origin', remote_url)
-        else:
-            print("ℹ️ Using existing Git repository")
-            repo = Repo(repo_dir)
-            repo.git.add(A=True)
-            if repo.is_dirty() or len(repo.untracked_files) > 0:
-                print("ℹ️ Committing changes")
-                repo.index.commit("Update from Karbon")
-                origin = repo.remote(name='origin')
-            else:
-                print("ℹ️ No changes to commit")
-                origin = repo.remote(name='origin')
+#     try:
+#         print(f"🔍 Checking repository directory: {repo_dir}")
+#         if not os.path.exists(os.path.join(repo_dir, ".git")):
+#             print("ℹ️ Initializing new Git repository")
+#             repo = Repo.init(repo_dir)
+#             repo.git.add(A=True)
+#             repo.index.commit("Initial commit from Karbon")
+#             print(f"ℹ️ Adding remote: {username}/{repo_name}")
+#             origin = repo.create_remote('origin', remote_url)
+#         else:
+#             print("ℹ️ Using existing Git repository")
+#             repo = Repo(repo_dir)
+#             repo.git.add(A=True)
+#             if repo.is_dirty() or len(repo.untracked_files) > 0:
+#                 print("ℹ️ Committing changes")
+#                 repo.index.commit("Update from Karbon")
+#                 origin = repo.remote(name='origin')
+#             else:
+#                 print("ℹ️ No changes to commit")
+#                 origin = repo.remote(name='origin')
 
-        print("📤 Pushing to GitHub...")
-        origin.push(refspec='master:main')
-        print(f"✅ Pushed to GitHub: {remote_url}")
-        return True
+#         print("📤 Pushing to GitHub...")
+#         origin.push(refspec='master:main')
+#         print(f"✅ Pushed to GitHub: {remote_url}")
+#         return True
 
-    except Exception as e:
-        print(f"❌ Push failed: {e}")
-        return False
+#     except Exception as e:
+#         print(f"❌ Push failed: {e}")
+#         return False
diff --git a/test_netlify_api.py b/test_netlify_api.py
new file mode 100644
index 00000000..0af7ac1b
--- /dev/null
+++ b/test_netlify_api.py
@@ -0,0 +1,26 @@
+import requests
+from token_manager import get_token, NETLIFY_SERVICE
+
+def test_netlify_token():
+    token = get_token(NETLIFY_SERVICE)
+    if not token:
+        print("❌ No Netlify token found. Please save it first using token_manager.py")
+        return
+
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+
+    url = "https://api.netlify.com/api/v1/sites"
+    response = requests.get(url, headers=headers)
+
+    if response.status_code == 200:
+        sites = response.json()
+        print("✅ Token works! Found the following sites:")
+        for site in sites:
+            print(f" - {site.get('name')} ({site.get('url')})")
+    else:
+        print(f"❌ API call failed: {response.status_code} - {response.text}")
+
+if __name__ == "__main__":
+    test_netlify_token()
diff --git a/test_pyautogui_basic.py b/test_pyautogui_basic.py
new file mode 100644
index 00000000..b79ff10b
--- /dev/null
+++ b/test_pyautogui_basic.py
@@ -0,0 +1,9 @@
+import pyautogui
+import time
+
+print("You have 3 seconds to switch to a text editor or input box...")
+time.sleep(3)
+
+pyautogui.typewrite("Hello from PyAutoGUI!\n", interval=0.1)
+pyautogui.press("enter")
+pyautogui.press("tab")
diff --git a/test_vercel_api.py b/test_vercel_api.py
new file mode 100644
index 00000000..ad7abc36
--- /dev/null
+++ b/test_vercel_api.py
@@ -0,0 +1,28 @@
+import requests
+from token_manager import get_token
+
+VERCEL_SERVICE = "vercel"
+
+def test_vercel_token():
+    token = get_token(VERCEL_SERVICE)
+    if not token:
+        print("❌ No Vercel token found. Please save it first using token_manager.py")
+        return
+
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+
+    url = "https://api.vercel.com/v9/projects"
+    response = requests.get(url, headers=headers)
+
+    if response.status_code == 200:
+        projects = response.json().get("projects", [])
+        print("✅ Token works! Found the following projects:")
+        for proj in projects:
+            print(f" - {proj.get('name')} (ID: {proj.get('id')})")
+    else:
+        print(f"❌ API call failed: {response.status_code} - {response.text}")
+
+if __name__ == "__main__":
+    test_vercel_token()
diff --git a/tests/test_ui_end_to_end.py b/tests/test_ui_end_to_end.py
new file mode 100644
index 00000000..3e6c26f0
--- /dev/null
+++ b/tests/test_ui_end_to_end.py
@@ -0,0 +1,127 @@
+import sys, os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+import pytest
+import tkinter as tk
+from ui_items.prompt_view import PromptView
+
+@pytest.fixture
+def prompt_view():
+    root = tk.Tk()
+
+    # Dummy callbacks
+    def dummy_generate(*args, **kwargs):
+        return None
+
+    def dummy_get_api_key():
+        return "fake-key"
+
+    def dummy_get_model_source():
+        return "fake-model"
+
+    dummy_examples = [{"prompt": "Example prompt"}]
+
+    # ✅ Pass all required args
+    view = PromptView(
+        root,
+        on_generate=dummy_generate,
+        get_api_key_callback=dummy_get_api_key,
+        get_model_source_callback=dummy_get_model_source,
+        examples_data=dummy_examples
+    )
+
+    yield view
+    root.destroy()
+
+
+def test_clear_button(prompt_view):
+    # Insert sample text
+    prompt_view.text_input.insert("1.0", "Some text")
+
+    # Call clear_input
+    prompt_view.clear_input()
+
+       # Assert textbox contains the placeholder text
+    content = prompt_view.text_input.get("1.0", tk.END).strip()
+    assert "Describe your dream website" in content
+
+
+def test_surprise_me_button(prompt_view):
+    # Call random_idea (same as clicking Surprise Me)
+    prompt_view.random_idea()
+
+    # Assert that prompt_input is not empty after surprise
+    assert prompt_view.text_input.get("1.0", tk.END).strip() != ""
+
+
+
+@pytest.fixture
+def prompt_view():
+    root = tk.Tk()
+
+    def dummy(): return None
+    view = PromptView(
+        root,
+        on_generate=dummy,
+        get_api_key_callback=dummy,
+        get_model_source_callback=dummy,
+        examples_data=[{"prompt": "Example: Build a blog"}]
+    )
+    yield view
+    root.destroy()
+
+def test_example_prompt_insertion(prompt_view):
+    """Ensure clicking an example prompt button inserts it into textbox"""
+
+    def walk(widget):
+        yield widget
+        for child in widget.winfo_children():
+            yield from walk(child)
+
+    example_btn = None
+    for w in walk(prompt_view):
+        if isinstance(w, tk.Button):
+            text = w.cget("text")
+            if any(keyword in text for keyword in [
+                "Professional portfolio",
+                "E-commerce",
+                "Mobile-first",
+                "Dashboard",
+                "Blog",
+                "Restaurant"
+            ]):
+                example_btn = w
+                break
+
+    assert example_btn is not None, "No example prompt button found"
+
+    # Simulate click
+    example_btn.invoke()
+
+    # Verify inserted text contains the clicked prompt (ignoring emojis)
+    inserted_text = prompt_view.text_input.get("1.0", tk.END).strip()
+    clean_btn_text = example_btn.cget("text").lstrip("💼🛍️📱📊📝🍔").strip()
+
+    assert clean_btn_text in inserted_text
+
+
+def test_output_panel_updates(prompt_view):
+    """Ensure that clicking Generate eventually updates output"""
+
+    # Insert a prompt
+    prompt_view.text_input.delete("1.0", tk.END)
+    prompt_view.text_input.insert("1.0", "Build me a portfolio website")
+
+    # Simulate clicking Generate
+    prompt_view.generate_btn.invoke()
+
+    # Manually simulate generation complete (since no real backend is called)
+    prompt_view.generation_complete("<html>mock site</html>", "Build me a portfolio website")
+
+    # ✅ Now just check the UI directly instead of relying on on_generate
+    if hasattr(prompt_view, "output_panel"):
+        output_text = prompt_view.output_panel.get("1.0", "end").strip()
+        assert "<html>mock site</html>" in output_text
+    else:
+        # Fallback: at least check no crash happened
+        assert True
diff --git a/token_manager_ui.py b/token_manager_ui.py
new file mode 100644
index 00000000..504450b7
--- /dev/null
+++ b/token_manager_ui.py
@@ -0,0 +1,48 @@
+import tkinter as tk
+from tkinter import messagebox
+from core.token_manager import save_token, get_token, NETLIFY_SERVICE, VERCEL_SERVICE
+
+class TokenManagerUI:
+    def __init__(self, parent):
+        self.window = tk.Toplevel(parent)
+        self.window.title("Manage Deployment Tokens")
+        self.window.geometry("400x250")
+        self.window.configure(bg="#0d1117")
+
+        # Title
+        tk.Label(self.window, text="🔐 Manage Deployment Tokens",
+                 font=("Segoe UI", 12, "bold"), bg="#0d1117", fg="white").pack(pady=10)
+
+        # Netlify Token
+        tk.Label(self.window, text="Netlify Token:", bg="#0d1117", fg="white").pack(anchor="w", padx=20)
+        self.netlify_entry = tk.Entry(self.window, width=40, show="*")
+        self.netlify_entry.pack(padx=20, pady=5)
+
+        # Pre-fill if already saved
+        if get_token(NETLIFY_SERVICE):
+            self.netlify_entry.insert(0, "************")
+
+        # Vercel Token
+        tk.Label(self.window, text="Vercel Token:", bg="#0d1117", fg="white").pack(anchor="w", padx=20, pady=(10,0))
+        self.vercel_entry = tk.Entry(self.window, width=40, show="*")
+        self.vercel_entry.pack(padx=20, pady=5)
+
+        if get_token(VERCEL_SERVICE):
+            self.vercel_entry.insert(0, "************")
+
+        # Save Button
+        tk.Button(self.window, text="Save Tokens", command=self.save_tokens,
+                  bg="#238636", fg="white", relief="flat", width=20).pack(pady=20)
+
+    def save_tokens(self):
+        netlify_token = self.netlify_entry.get().strip()
+        vercel_token = self.vercel_entry.get().strip()
+
+        if netlify_token and netlify_token != "************":
+            save_token(NETLIFY_SERVICE, netlify_token)
+
+        if vercel_token and vercel_token != "************":
+            save_token(VERCEL_SERVICE, vercel_token)
+
+        messagebox.showinfo("Success", "✅ Tokens saved securely!")
+        self.window.destroy()
diff --git a/tokens.json b/tokens.json
new file mode 100644
index 00000000..c1020e89
--- /dev/null
+++ b/tokens.json
@@ -0,0 +1 @@
+{"vercel": "VyYAqCAsiRKwBgADvJZY2wwE"}
\ No newline at end of file
diff --git a/ui_items/editor_view.py b/ui_items/editor_view.py
index 202dc76a..8af956ce 100644
--- a/ui_items/editor_view.py
+++ b/ui_items/editor_view.py
@@ -95,6 +95,19 @@ def __init__(self, master, get_code_callback, set_code_callback, get_api_key_cal
         self.activity_indicator_label = None
 
         self.setup_ui()
+    def deploy_to_netlify(self):
+        from exporters.deploy_netlify import deploy_netlify
+
+        code = self.code_editor.get("1.0", tk.END).strip()
+        if not code:
+            messagebox.showerror("Error", "⚠️ No code to deploy!")
+            return
+
+        success, message = deploy_netlify(code)
+        if success:
+            messagebox.showinfo("Netlify Deployment", message)
+        else:
+            messagebox.showerror("Netlify Deployment Failed", message)
 
     def setup_ui(self):
         self.create_header()
@@ -538,6 +551,44 @@ def create_tips_section(self, parent):
 
         tk.Label(tips_frame, text="", bg='#0d1117').pack(pady=8)
 
+            # Deployment Buttons
+        deploy_frame = tk.Frame(self, bg="#0d1117")
+        deploy_frame.pack(pady=10)
+
+        netlify_btn = tk.Button(
+            deploy_frame,
+            text="🚀 Deploy to Netlify",
+            bg="#2ea043", fg="white",
+            command=self.deploy_to_netlify
+        )
+        netlify_btn.pack(side=tk.LEFT, padx=5)
+
+        vercel_btn = tk.Button(
+            deploy_frame,
+            text="🚀 Deploy to Vercel",
+            bg="#0070f3", fg="white",
+            command=self.deploy_to_vercel
+        )
+        vercel_btn.pack(side=tk.LEFT, padx=5)
+        def deploy_to_netlify(self):
+            from exporters.deploy_netlify import deploy_netlify
+            code = self.get_code_callback()
+            success, msg = deploy_netlify(code)
+            self.show_deploy_status(success, msg)
+
+    def deploy_to_vercel(self):
+        from exporters.deploy_vercel import deploy_vercel
+        code = self.get_code_callback()
+        success, msg = deploy_vercel(code)
+        self.show_deploy_status(success, msg)
+
+    def show_deploy_status(self, success, message):
+        import tkinter.messagebox as mb
+        if success:
+            mb.showinfo("Deployment Success", message)
+        else:
+            mb.showerror("Deployment Failed", message)
+
     def create_status_bar(self):
         self.status_frame = tk.Frame(self, bg='#161b22', height=35)
         self.status_frame.pack(fill="x", side="bottom")
diff --git a/ui_items/karbon_ui.py b/ui_items/karbon_ui.py
index 8b4aa009..66f4e96f 100644
--- a/ui_items/karbon_ui.py
+++ b/ui_items/karbon_ui.py
@@ -10,10 +10,15 @@
 from ui_items.editor_view import EditorView, open_html_in_browser
 from ui_items.token_manager_view import TokenManagerView
 from contributors_page import ContributorsPage
-
+from utils.preview import update_preview
 from core.ai_engine import ai_status, generate_code_from_prompt
-from exporters.exporter import export_code, export_to_github
-from exporters.repo_pusher import push_to_github
+from exporters.exporter import export_code
+'''from exporters.repo_pusher import push_to_github'''
+from core.token_manager import get_token, save_token, NETLIFY_SERVICE, VERCEL_SERVICE
+from exporters.deploy_vercel import deploy_vercel
+from exporters.deploy_netlify import deploy_netlify
+from token_manager_ui import TokenManagerUI
+
 
 EXAMPLES = {
     "Login Page": "Create a login page using HTML and Tailwind CSS",
@@ -66,6 +71,27 @@ def __init__(self, root, user=None):
         self.history_button = tk.Button(
               self.main_container, text="View History", command=self.show_history_panel)
         self.history_button.pack(pady=(0, 10))
+        # Manage Tokens Button
+        self.tokens_button = tk.Button(
+        self.main_container,
+        text="🔐 Manage Tokens",
+        command=lambda: TokenManagerUI(self.root)
+)
+        self.tokens_button.pack(pady=(0, 10))
+
+        # Deploy to Netlify Button
+        self.netlify_button = tk.Button(
+        self.main_container,
+        text="🚀 Deploy to Netlify",
+        command=self.deploy_to_netlify,
+        bg="#238636",
+        fg="white",
+        relief="flat",
+        width=20
+)
+        self.netlify_button.pack(pady=(0, 10))
+
+
 
 
         self.load_settings()
@@ -111,6 +137,40 @@ def __init__(self, root, user=None):
         self.animate_title()
         self.update_ai_status_indicator()
         self.apply_user_appearance()
+
+
+
+
+
+
+                # ===== Menu Bar =====
+        self.menu_bar = tk.Menu(self.root, bg="#0d1117", fg="white", tearoff=0)
+        self.root.config(menu=self.menu_bar)
+
+        # File Menu
+        self.file_menu = tk.Menu(self.menu_bar, tearoff=0)
+        self.menu_bar.add_cascade(label="File", menu=self.file_menu)
+
+        # Settings Menu
+        self.settings_menu = tk.Menu(self.menu_bar, tearoff=0)
+        self.menu_bar.add_cascade(label="Settings", menu=self.settings_menu)
+
+        # Add Hosting Token Manager under Settings
+        self.settings_menu.add_command(
+            label="Manage Hosting Tokens",
+            command=self.show_hosting_token_manager
+        )
+    
+    def deploy_to_netlify(self):
+        from deployers.netlify_deployer import deploy_netlify
+        success, message = deploy_netlify(self.get_code())
+        tk.messagebox.showinfo("Netlify Deployment", message)
+
+
+    def show_hosting_token_manager(self):
+        from hosting_token_ui import HostingTokenManager
+        HostingTokenManager(self.root)
+
     def show_history_panel(self):
         if not self.history:
             messagebox.showinfo("History", "No history available.")
@@ -1912,6 +1972,40 @@ def show_token_manager(self):
 
         self.update_status("GitHub Token Manager", "🔐")
 
+        
+        def show_hosting_token_manager(self):
+            """UI for managing Netlify and Vercel tokens"""
+        self.clear_content()
+        token_window = tk.Frame(self.main_container, bg="#0d1117")
+        token_window.pack(fill="both", expand=True, padx=20, pady=(0, 20))
+
+        tk.Label(token_window, text="Netlify Token", fg="white", bg="#0d1117").pack(pady=5)
+        netlify_entry = tk.Entry(token_window, show="*", width=40)
+        netlify_entry.pack(pady=5)
+
+        def save_netlify():
+            token = netlify_entry.get().strip()
+            if token:
+                save_token(NETLIFY_SERVICE, token)
+                self.show_notification("✅ Netlify token saved", "success")
+
+        tk.Button(token_window, text="Save Netlify Token", command=save_netlify).pack(pady=5)
+
+        tk.Label(token_window, text="Vercel Token", fg="white", bg="#0d1117").pack(pady=5)
+        vercel_entry = tk.Entry(token_window, show="*", width=40)
+        vercel_entry.pack(pady=5)
+
+        def save_vercel():
+            token = vercel_entry.get().strip()
+            if token:
+                save_token(VERCEL_SERVICE, token)
+                self.show_notification("✅ Vercel token saved", "success")
+
+        tk.Button(token_window, text="Save Vercel Token", command=save_vercel).pack(pady=5)
+
+        self.status_frame.pack(fill="x", side="bottom")
+        self.update_status("Hosting Token Manager", "🔐")
+
     def handle_export(self):
         from exporters.exporter import export_code, export_to_github, validate_github_token
         from core.token_manager import decrypt_token
@@ -1948,6 +2042,21 @@ def handle_export(self):
         else:
             self.show_notification("Failed to push to GitHub. Check console for details.", "error")
 
+        def deploy_to_netlify(self):
+            result = deploy_netlify()
+            if result:
+                self.show_notification(f"Netlify: {result}", "success")
+            else:
+                self.show_notification("Netlify deployment failed", "error")
+
+    def deploy_to_vercel(self):
+        result = deploy_vercel()
+        if result:
+            self.show_notification(f"Vercel: {result}", "success")
+        else:
+            self.show_notification("Vercel deployment failed", "error")
+
+
     def show_notification(self, message, type="info"):
         colors = {
             "info": "#58a6ff",
diff --git a/ui_items/token_manager_view.py b/ui_items/token_manager_view.py
index 461a5951..6bf859c6 100644
--- a/ui_items/token_manager_view.py
+++ b/ui_items/token_manager_view.py
@@ -3,8 +3,9 @@
 import threading
 import webbrowser
 import os
-from core.token_manager import encrypt_token, decrypt_token, clear_token, token_exists, ERROR_NO_TOKEN, SUCCESS_TOKEN_SAVED
-from exporters.exporter import validate_github_token
+
+from core.token_manager import save_token, get_token, clear_token, NETLIFY_SERVICE, VERCEL_SERVICE
+
 
 class TokenManagerView(ttk.Frame):
     def __init__(self, parent, back_callback):
diff --git a/users/hiii/history.json b/users/hiii/history.json
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/users/hiii/history.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/users/hiii/preferences.json b/users/hiii/preferences.json
new file mode 100644
index 00000000..84bdf0ac
--- /dev/null
+++ b/users/hiii/preferences.json
@@ -0,0 +1 @@
+{"theme": "light", "font_size": 12}
\ No newline at end of file
diff --git a/users/lala/history.json b/users/lala/history.json
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/users/lala/history.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/users/lala/preferences.json b/users/lala/preferences.json
new file mode 100644
index 00000000..84bdf0ac
--- /dev/null
+++ b/users/lala/preferences.json
@@ -0,0 +1 @@
+{"theme": "light", "font_size": 12}
\ No newline at end of file
diff --git a/users/newuser/history.json b/users/newuser/history.json
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/users/newuser/history.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/users/newuser/preferences.json b/users/newuser/preferences.json
new file mode 100644
index 00000000..84bdf0ac
--- /dev/null
+++ b/users/newuser/preferences.json
@@ -0,0 +1 @@
+{"theme": "light", "font_size": 12}
\ No newline at end of file
diff --git a/users/test/history.json b/users/test/history.json
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/users/test/history.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/users/test/preferences.json b/users/test/preferences.json
new file mode 100644
index 00000000..84bdf0ac
--- /dev/null
+++ b/users/test/preferences.json
@@ -0,0 +1 @@
+{"theme": "light", "font_size": 12}
\ No newline at end of file