diff --git a/client/src/app.tsx b/client/src/app.tsx
index ba9a5a5..9733584 100644
--- a/client/src/app.tsx
+++ b/client/src/app.tsx
@@ -4,6 +4,8 @@ import { Layout } from "./components/Layout";
 import { ReloadPrompt } from "./components/ReloadPrompt";
 import { ConnectWhatsApp } from "./pages/ConnectWhatsApp";
 import { CreateSchedule } from "./pages/CreateSchedule";
+import { Contacts } from "./pages/Contacts";
+import { Broadcasts } from "./pages/Broadcasts";
 import { Feedbacks } from "./pages/Feedbacks";
 import { Schedules } from "./pages/Schedules";
 import { Settings } from "./pages/Settings";
@@ -50,6 +52,8 @@ export function App() {
       <Switch>
         <Route path="/" component={Schedules} />
         <Route path="/create" component={CreateSchedule} />
+        <Route path="/contacts" component={Contacts} />
+        <Route path="/broadcasts" component={Broadcasts} />
         <Route path="/feedbacks" component={Feedbacks} />
         <Route path="/settings" component={Settings} />
         <Route>
diff --git a/client/src/components/Layout.tsx b/client/src/components/Layout.tsx
index e0cf19c..4e8743f 100644
--- a/client/src/components/Layout.tsx
+++ b/client/src/components/Layout.tsx
@@ -1,4 +1,11 @@
-import { Calendar, MessageSquare, Plus, Settings } from "lucide-preact";
+import {
+  Calendar,
+  MessageSquare,
+  Megaphone,
+  Plus,
+  Settings,
+  Users,
+} from "lucide-preact";
 import { Link, useLocation } from "wouter-preact";
 
 export function Layout({ children }: { children: any }) {
@@ -7,6 +14,8 @@ export function Layout({ children }: { children: any }) {
   const navItems = [
     { href: "/", icon: Calendar, label: "Schedules" },
     { href: "/create", icon: Plus, label: "Create" },
+    { href: "/contacts", icon: Users, label: "Contacts" },
+    { href: "/broadcasts", icon: Megaphone, label: "Broadcasts" },
     { href: "/feedbacks", icon: MessageSquare, label: "Feedbacks" },
     { href: "/settings", icon: Settings, label: "Settings" },
   ];
diff --git a/client/src/pages/Broadcasts.tsx b/client/src/pages/Broadcasts.tsx
new file mode 100644
index 0000000..9b55ab2
--- /dev/null
+++ b/client/src/pages/Broadcasts.tsx
@@ -0,0 +1,327 @@
+import type { Broadcast, Contact, CreateBroadcastDto } from "@shared/types";
+import { Megaphone, Plus, Trash2 } from "lucide-preact";
+import { useEffect, useState } from "preact/hooks";
+import { api } from "../services/api";
+import "./common.css";
+
+export function Broadcasts() {
+  const [broadcasts, setBroadcasts] = useState<Broadcast[]>([]);
+  const [contacts, setContacts] = useState<Contact[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [showCreate, setShowCreate] = useState(false);
+
+  const [formData, setFormData] = useState<CreateBroadcastDto>({
+    name: "",
+    message: "",
+    contactIds: [],
+    scheduledTime: undefined,
+    type: "instant",
+    intervalValue: 1,
+    intervalUnit: "day",
+  });
+  const [attachment, setAttachment] = useState<File | null>(null);
+
+  const loadData = async () => {
+    try {
+      const [bData, cData] = await Promise.all([
+        api.getBroadcasts(),
+        api.getContacts(),
+      ]);
+      setBroadcasts(bData);
+      setContacts(cData);
+    } catch (err) {
+      console.error(err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    loadData();
+  }, []);
+
+  const handleDelete = async (id: number) => {
+    if (confirm("Delete this broadcast?")) {
+      await api.deleteBroadcast(id);
+      loadData();
+    }
+  };
+
+  const handleCreate = async (e: Event) => {
+    e.preventDefault();
+    try {
+      if (formData.contactIds.length === 0) {
+        alert("Please select at least one contact");
+        return;
+      }
+
+      const form = new FormData();
+      form.append("name", formData.name);
+      form.append("message", formData.message);
+      form.append("contactIds", JSON.stringify(formData.contactIds));
+      form.append("type", formData.type || "instant");
+
+      if (formData.type !== "instant" && formData.scheduledTime) {
+        form.append("scheduledTime", formData.scheduledTime);
+      }
+
+      if (formData.type === "recurring") {
+        if (formData.intervalValue)
+          form.append("intervalValue", formData.intervalValue.toString());
+        if (formData.intervalUnit)
+          form.append("intervalUnit", formData.intervalUnit);
+      }
+
+      if (attachment) {
+        form.append("attachment", attachment);
+      }
+
+      await api.createBroadcast(form);
+      setShowCreate(false);
+      setAttachment(null);
+      setFormData({
+        name: "",
+        message: "",
+        contactIds: [],
+        scheduledTime: undefined,
+        type: "instant",
+        intervalValue: 1,
+        intervalUnit: "day",
+      });
+      loadData();
+    } catch (err: any) {
+      alert(err.message);
+    }
+  };
+
+  const toggleContact = (id: number) => {
+    const current = formData.contactIds;
+    if (current.includes(id)) {
+      setFormData({
+        ...formData,
+        contactIds: current.filter((cid) => cid !== id),
+      });
+    } else {
+      setFormData({ ...formData, contactIds: [...current, id] });
+    }
+  };
+
+  const toggleSelectAll = () => {
+    if (formData.contactIds.length === contacts.length) {
+      setFormData({ ...formData, contactIds: [] });
+    } else {
+      setFormData({ ...formData, contactIds: contacts.map((c) => c.id) });
+    }
+  };
+
+  if (loading) return <div>Loading...</div>;
+
+  return (
+    <div class="page-container">
+      <div class="page-header">
+        <h2>Broadcasts</h2>
+        <button class="btn-primary" onClick={() => setShowCreate(!showCreate)}>
+          <Plus size={18} /> New Broadcast
+        </button>
+      </div>
+
+      {showCreate && (
+        <form class="create-form" onSubmit={handleCreate}>
+          <h3>New Broadcast</h3>
+          <div class="form-group">
+            <label>Campaign Name</label>
+            <input
+              type="text"
+              value={formData.name}
+              onInput={(e) =>
+                setFormData({ ...formData, name: e.currentTarget.value })
+              }
+              required
+            />
+          </div>
+
+          <div class="form-group">
+            <label>Type</label>
+            <div class="type-selector">
+              {(["instant", "once", "recurring"] as const).map((t) => (
+                <button
+                  type="button"
+                  key={t}
+                  class={formData.type === t ? "active" : ""}
+                  onClick={() => setFormData({ ...formData, type: t })}
+                >
+                  {t.charAt(0).toUpperCase() + t.slice(1)}
+                </button>
+              ))}
+            </div>
+          </div>
+
+          {formData.type !== "instant" && (
+            <div class="form-group">
+              <label>
+                {formData.type === "recurring"
+                  ? "Start Time"
+                  : "Scheduled Time"}
+              </label>
+              <input
+                type="datetime-local"
+                value={formData.scheduledTime || ""}
+                onInput={(e) =>
+                  setFormData({
+                    ...formData,
+                    scheduledTime: e.currentTarget.value,
+                  })
+                }
+                required
+              />
+            </div>
+          )}
+
+          {formData.type === "recurring" && (
+            <div class="form-group" style={{ display: "flex", gap: "10px" }}>
+              <div style={{ flex: 1 }}>
+                <label>Repeat Every</label>
+                <input
+                  type="number"
+                  min="1"
+                  value={formData.intervalValue}
+                  onInput={(e) =>
+                    setFormData({
+                      ...formData,
+                      intervalValue: parseInt(e.currentTarget.value),
+                    })
+                  }
+                  required
+                />
+              </div>
+              <div style={{ flex: 1 }}>
+                <label>Unit</label>
+                <select
+                  value={formData.intervalUnit}
+                  onChange={(e) =>
+                    setFormData({
+                      ...formData,
+                      intervalUnit: e.currentTarget.value as any,
+                    })
+                  }
+                  style={{ width: "100%", padding: "0.5rem" }}
+                >
+                  <option value="minute">Minutes</option>
+                  <option value="hour">Hours</option>
+                  <option value="day">Days</option>
+                  <option value="week">Weeks</option>
+                  <option value="month">Months</option>
+                </select>
+              </div>
+            </div>
+          )}
+
+          <div class="form-group">
+            <label>Message</label>
+            <textarea
+              value={formData.message}
+              onInput={(e) =>
+                setFormData({ ...formData, message: e.currentTarget.value })
+              }
+              required
+              rows={3}
+            />
+          </div>
+
+          <div class="form-group">
+            <label>Attachment (Optional)</label>
+            <input
+              type="file"
+              onChange={(e) =>
+                setAttachment(e.currentTarget.files?.[0] || null)
+              }
+              style={{
+                width: "100%",
+                padding: "8px",
+                border: "1px solid #ddd",
+                borderRadius: "4px",
+              }}
+            />
+          </div>
+
+          <div class="form-group">
+            <label>Recipients ({formData.contactIds.length} selected)</label>
+            <div class="contact-selector">
+              <div class="selector-actions">
+                <button
+                  type="button"
+                  onClick={toggleSelectAll}
+                  class="btn-small"
+                >
+                  {formData.contactIds.length === contacts.length
+                    ? "Deselect All"
+                    : "Select All"}
+                </button>
+              </div>
+              <div class="contact-list-scroll">
+                {contacts.map((contact) => (
+                  <label key={contact.id} class="checkbox-label">
+                    <input
+                      type="checkbox"
+                      checked={formData.contactIds.includes(contact.id)}
+                      onChange={() => toggleContact(contact.id)}
+                    />
+                    <span>
+                      {contact.name} ({contact.number})
+                    </span>
+                  </label>
+                ))}
+              </div>
+            </div>
+          </div>
+
+          <div class="form-actions">
+            <button type="submit" class="btn-submit">
+              Create Broadcast
+            </button>
+            <button
+              type="button"
+              class="btn-cancel"
+              onClick={() => setShowCreate(false)}
+            >
+              Cancel
+            </button>
+          </div>
+        </form>
+      )}
+
+      {broadcasts.length === 0 ? (
+        <p class="empty-state">No broadcasts yet.</p>
+      ) : (
+        <div class="card-list">
+          {broadcasts.map((b) => (
+            <div class={`card status-${b.status}`} key={b.id}>
+              <div class="card-header">
+                <div class="card-title">
+                  <Megaphone size={16} />
+                  <span>{b.name}</span>
+                </div>
+                <div class="card-actions">
+                  <span class={`status-badge ${b.status}`}>{b.status}</span>
+                  <button onClick={() => handleDelete(b.id)} class="btn-icon">
+                    <Trash2 size={16} />
+                  </button>
+                </div>
+              </div>
+              <div class="card-body">
+                <p class="message-preview">{b.message}</p>
+                <div class="card-meta">
+                  {b.scheduledTime && (
+                    <p>
+                      Scheduled: {new Date(b.scheduledTime).toLocaleString()}
+                    </p>
+                  )}
+                </div>
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/client/src/pages/Contacts.tsx b/client/src/pages/Contacts.tsx
new file mode 100644
index 0000000..7673f5b
--- /dev/null
+++ b/client/src/pages/Contacts.tsx
@@ -0,0 +1,293 @@
+import type { Contact, CreateContactDto } from "@shared/types";
+import { Download, Plus, Trash2, Upload, Users } from "lucide-preact";
+import { useEffect, useState } from "preact/hooks";
+import { api } from "../services/api";
+import "./common.css"; // Reuse or create a common CSS
+
+export function Contacts() {
+  const [contacts, setContacts] = useState<Contact[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [showCreate, setShowCreate] = useState(false);
+
+  // Form state
+  const [formData, setFormData] = useState<CreateContactDto>({
+    name: "",
+    number: "",
+    email: "",
+    companyName: "",
+  });
+
+  const loadContacts = async () => {
+    try {
+      const data = await api.getContacts();
+      setContacts(data);
+    } catch (err) {
+      console.error(err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    loadContacts();
+  }, []);
+
+  const handleDelete = async (id: number) => {
+    if (confirm("Delete this contact?")) {
+      await api.deleteContact(id);
+      loadContacts();
+    }
+  };
+
+  const handleDeleteAll = async () => {
+    if (
+      confirm(
+        "Are you sure you want to delete ALL contacts? This cannot be undone."
+      )
+    ) {
+      try {
+        await api.deleteAllContacts();
+        loadContacts();
+      } catch (err: any) {
+        alert(err.message);
+      }
+    }
+  };
+
+  const handleCreate = async (e: Event) => {
+    e.preventDefault();
+    try {
+      await api.createContact(formData);
+      setShowCreate(false);
+      setFormData({ name: "", number: "", email: "", companyName: "" });
+      loadContacts();
+    } catch (err: any) {
+      alert(err.message);
+    }
+  };
+
+  const handleDownloadTemplate = () => {
+    const headers = ["name", "number", "email", "companyName"];
+    const csvContent =
+      "data:text/csv;charset=utf-8," +
+      headers.join(",") +
+      "\n" +
+      "Example Name,1234567890,example@test.com,Example Corp";
+    const encodedUri = encodeURI(csvContent);
+    const link = document.createElement("a");
+    link.setAttribute("href", encodedUri);
+    link.setAttribute("download", "contacts_template.csv");
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  };
+
+  const handleFileUpload = async (e: Event) => {
+    const input = e.target as HTMLInputElement;
+    if (!input.files || input.files.length === 0) return;
+
+    const file = input.files[0];
+    const reader = new FileReader();
+
+    reader.onload = async (evt) => {
+      const text = evt.target?.result as string;
+      if (!text) return;
+
+      const lines = text.split(/\r\n|\n/);
+      const headers = lines[0].split(",").map((h) => h.trim());
+
+      // Simple validation of headers
+      if (!headers.includes("name") || !headers.includes("number")) {
+        alert("Invalid CSV format. Missing 'name' or 'number' columns.");
+        return;
+      }
+
+      const contactsToUpload = [];
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line) continue;
+
+        // Determine delimiter (comma or semicolon) - simplified for now assumes comma
+        // A better parser would handle quoted strings containing commas.
+        // Since I cannot install libraries, I'll do a basic split which is brittle but likely sufficient for the template.
+        const values = line.split(",");
+
+        const contact: any = {};
+        headers.forEach((header, index) => {
+          if (values[index]) {
+            contact[header] = values[index].trim();
+          }
+        });
+
+        if (contact.name && contact.number) {
+          contactsToUpload.push(contact);
+        }
+      }
+
+      if (contactsToUpload.length > 0) {
+        try {
+          const res = await api.createContactsBulk(contactsToUpload);
+          let msg = `Imported ${res.success} contacts.`;
+          if (res.failed > 0) {
+            msg += ` Failed: ${res.failed}. Check console for details.`;
+            console.error("Import errors:", res.errors);
+          }
+          alert(msg);
+          loadContacts();
+        } catch (err: any) {
+          alert("Failed to upload: " + err.message);
+        }
+      } else {
+        alert("No valid contacts found in file.");
+      }
+
+      // Reset input
+      input.value = "";
+    };
+
+    reader.readAsText(file);
+  };
+
+  if (loading && contacts.length === 0) return <div>Loading...</div>;
+
+  return (
+    <div class="page-container">
+      <div class="page-header">
+        <h2>Contacts</h2>
+        <div class="actions">
+          {contacts.length > 0 && (
+            <button
+              class="btn-cancel"
+              onClick={handleDeleteAll}
+              style={{ backgroundColor: "#ff4444", color: "white" }}
+            >
+              <Trash2 size={18} /> Remove All
+            </button>
+          )}
+          <button class="btn-secondary" onClick={handleDownloadTemplate}>
+            <Download size={18} /> Template
+          </button>
+          <label
+            class="btn-secondary"
+            style={{
+              cursor: "pointer",
+              display: "inline-flex",
+              alignItems: "center",
+              gap: "0.5rem",
+            }}
+          >
+            <Upload size={18} /> Upload CSV
+            <input
+              type="file"
+              accept=".csv"
+              onChange={handleFileUpload}
+              style={{ display: "none" }}
+            />
+          </label>
+          <button
+            class="btn-primary"
+            onClick={() => setShowCreate(!showCreate)}
+          >
+            <Plus size={18} /> Add Contact
+          </button>
+        </div>
+      </div>
+
+      {showCreate && (
+        <form class="create-form" onSubmit={handleCreate}>
+          <h3>New Contact</h3>
+          <div class="form-group">
+            <label>Name</label>
+            <input
+              type="text"
+              value={formData.name}
+              onInput={(e) =>
+                setFormData({ ...formData, name: e.currentTarget.value })
+              }
+              required
+            />
+          </div>
+          <div class="form-group">
+            <label>Number (with country code)</label>
+            <input
+              type="text"
+              value={formData.number}
+              onInput={(e) =>
+                setFormData({ ...formData, number: e.currentTarget.value })
+              }
+              required
+              placeholder="e.g. 1234567890"
+            />
+          </div>
+          <div class="form-group">
+            <label>Email (Optional)</label>
+            <input
+              type="email"
+              value={formData.email}
+              onInput={(e) =>
+                setFormData({ ...formData, email: e.currentTarget.value })
+              }
+            />
+          </div>
+          <div class="form-group">
+            <label>Company Name (Optional)</label>
+            <input
+              type="text"
+              value={formData.companyName}
+              onInput={(e) =>
+                setFormData({ ...formData, companyName: e.currentTarget.value })
+              }
+            />
+          </div>
+          <div class="form-actions">
+            <button type="submit" class="btn-submit">
+              Save
+            </button>
+            <button
+              type="button"
+              class="btn-cancel"
+              onClick={() => setShowCreate(false)}
+            >
+              Cancel
+            </button>
+          </div>
+        </form>
+      )}
+
+      {contacts.length === 0 ? (
+        <p class="empty-state">No contacts yet.</p>
+      ) : (
+        <div class="card-list">
+          {contacts.map((c) => (
+            <div class="card" key={c.id}>
+              <div class="card-header">
+                <div class="card-title">
+                  <Users size={16} />
+                  <span>{c.name}</span>
+                </div>
+                <button onClick={() => handleDelete(c.id)} class="btn-icon">
+                  <Trash2 size={16} />
+                </button>
+              </div>
+              <div class="card-body">
+                <p>
+                  <strong>Number:</strong> {c.number}
+                </p>
+                {c.email && (
+                  <p>
+                    <strong>Email:</strong> {c.email}
+                  </p>
+                )}
+                {c.companyName && (
+                  <p>
+                    <strong>Company:</strong> {c.companyName}
+                  </p>
+                )}
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/client/src/pages/common.css b/client/src/pages/common.css
new file mode 100644
index 0000000..c685042
--- /dev/null
+++ b/client/src/pages/common.css
@@ -0,0 +1,288 @@
+/* Page Layout */
+.page-container {
+  max-width: 900px;
+  margin: 0 auto;
+  padding-bottom: 2rem;
+}
+
+.page-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 2rem;
+}
+
+.page-header h2 {
+  font-size: 1.5rem;
+  font-weight: 700;
+  color: var(--text);
+  margin: 0;
+}
+
+/* Base Buttons */
+.btn-primary {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  background: var(--primary);
+  color: white;
+  border: none;
+  padding: 0.5rem 1rem;
+  border-radius: var(--radius-md);
+  font-weight: 500;
+  cursor: pointer;
+  transition: background var(--transition-base);
+}
+
+.btn-primary:hover {
+  background: var(--primary-dark);
+}
+
+.btn-icon {
+  background: none;
+  border: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  padding: 0.25rem;
+  border-radius: var(--radius-sm);
+  transition: all var(--transition-base);
+}
+
+.btn-icon:hover {
+  color: var(--error);
+  background: var(--bg-hover);
+}
+
+/* Cards */
+.card-list {
+  display: grid;
+  gap: 1rem;
+}
+
+.card {
+  background: var(--surface);
+  backdrop-filter: var(--blur-md);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-lg);
+  padding: 1rem;
+  transition: border-color 0.2s;
+}
+
+.card:hover {
+  border-color: var(--primary-light);
+}
+
+.card-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  margin-bottom: 0.75rem;
+}
+
+.card-title {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-weight: 600;
+  color: var(--text);
+}
+
+.card-body p {
+  margin: 0.25rem 0;
+  color: var(--text-secondary);
+  font-size: 0.875rem;
+}
+
+/* Forms */
+.create-form {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-lg);
+  padding: 1.5rem;
+  margin-bottom: 2rem;
+  animation: slideDown 0.3s ease-out;
+}
+
+.create-form h3 {
+  margin-top: 0;
+  margin-bottom: 1.5rem;
+}
+
+.form-group {
+  margin-bottom: 1rem;
+}
+
+.form-group label {
+  display: block;
+  margin-bottom: 0.5rem;
+  font-weight: 500;
+  font-size: 0.875rem;
+}
+
+.form-group input,
+.form-group textarea,
+.form-group select {
+  width: 100%;
+  padding: 0.625rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md);
+  background: var(--input-bg);
+  color: var(--text);
+  font-size: 0.9.5rem;
+}
+
+.form-actions {
+  display: flex;
+  gap: 1rem;
+  margin-top: 1.5rem;
+}
+
+.btn-submit {
+  background: var(--primary);
+  color: white;
+  border: none;
+  padding: 0.625rem 1.25rem;
+  border-radius: var(--radius-md);
+  font-weight: 500;
+  cursor: pointer;
+}
+
+.btn-cancel {
+  background: transparent;
+  border: 1px solid var(--border);
+  color: var(--text);
+  padding: 0.625rem 1.25rem;
+  border-radius: var(--radius-md);
+  cursor: pointer;
+}
+
+/* Contact Selector specific */
+.contact-selector {
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md);
+  padding: 0.5rem;
+  background: var(--input-bg);
+}
+
+.selector-actions {
+  padding-bottom: 0.5rem;
+  border-bottom: 1px solid var(--border);
+  margin-bottom: 0.5rem;
+}
+
+.btn-small {
+  background: none;
+  border: none;
+  color: var(--primary);
+  font-size: 0.75rem;
+  cursor: pointer;
+  padding: 0;
+}
+
+.contact-list-scroll {
+  max-height: 200px;
+  overflow-y: auto;
+  display: grid;
+  gap: 0.5rem;
+}
+
+.checkbox-label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.875rem;
+  cursor: pointer;
+  padding: 0.25rem 0;
+}
+
+.checkbox-label span {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.status-badge {
+  display: inline-block;
+  padding: 0.25rem 0.5rem;
+  border-radius: 999px;
+  font-size: 0.75rem;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+
+.status-badge.draft {
+  background: #e5e5e5;
+  color: #333;
+}
+.status-badge.sent {
+  background: #d1fae5;
+  color: #047857;
+}
+.status-badge.scheduled {
+  background: #dbeafe;
+  color: #1e40af;
+}
+.status-badge.processing {
+  background: #fef3c7;
+  color: #b45309;
+}
+.status-badge.failed {
+  background: #fee2e2;
+  color: #b91c1c;
+}
+.status-badge.completed {
+  background: #d1fae5;
+  color: #047857;
+}
+
+/* Empty state */
+.empty-state {
+  text-align: center;
+  color: var(--text-secondary);
+  font-size: 1.125rem;
+  margin: 4rem 0;
+  padding: 3rem 2rem;
+  background: var(--surface);
+  border-radius: var(--radius-xl);
+  border: 2px dashed var(--border);
+}
+
+@keyframes slideDown {
+  from {
+    opacity: 0;
+    transform: translateY(-10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+/* Type Selector */
+.type-selector {
+  display: flex;
+  justify-content: flex-start;
+  gap: 1rem;
+  margin-bottom: 1rem;
+}
+
+.type-selector button {
+  background: var(--input-bg);
+  color: var(--text-secondary);
+  border: 1px solid var(--border);
+  padding: 0.5rem 1rem;
+  border-radius: 999px;
+  cursor: pointer;
+  transition: all 0.2s;
+  font-size: 0.875rem;
+}
+
+.type-selector button:hover {
+  background: var(--bg-hover);
+}
+
+.type-selector button.active {
+  background: var(--primary);
+  color: white;
+  border-color: var(--primary);
+}
diff --git a/client/src/services/api.ts b/client/src/services/api.ts
index db8a573..ce47cb2 100644
--- a/client/src/services/api.ts
+++ b/client/src/services/api.ts
@@ -148,4 +148,78 @@ export const api = {
     });
     if (!res.ok) throw new Error("Failed to update setting");
   },
+
+  // Contacts
+  getContacts: async (): Promise<any[]> => {
+    const res = await fetch(`${API_BASE}/contacts`);
+    if (!res.ok) throw new Error("Failed to fetch contacts");
+    return res.json();
+  },
+
+  createContact: async (data: any): Promise<any> => {
+    const res = await fetch(`${API_BASE}/contacts`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error || "Failed to create contact");
+    }
+    return res.json();
+  },
+
+  createContactsBulk: async (
+    data: any[]
+  ): Promise<{ success: number; failed: number; errors: string[] }> => {
+    const res = await fetch(`${API_BASE}/contacts/bulk`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+    });
+    if (!res.ok) throw new Error("Failed to upload contacts");
+    return res.json();
+  },
+
+  deleteContact: async (id: number): Promise<void> => {
+    const res = await fetch(`${API_BASE}/contacts/${id}`, {
+      method: "DELETE",
+    });
+    if (!res.ok) throw new Error("Failed to delete contact");
+  },
+
+  deleteAllContacts: async (): Promise<void> => {
+    const res = await fetch(`${API_BASE}/contacts`, {
+      method: "DELETE",
+    });
+    if (!res.ok) throw new Error("Failed to delete all contacts");
+  },
+
+  // Broadcasts
+  getBroadcasts: async (): Promise<any[]> => {
+    const res = await fetch(`${API_BASE}/broadcasts`);
+    if (!res.ok) throw new Error("Failed to fetch broadcasts");
+    return res.json();
+  },
+
+  createBroadcast: async (data: any): Promise<any> => {
+    const isFormData = data instanceof FormData;
+    const res = await fetch(`${API_BASE}/broadcasts`, {
+      method: "POST",
+      headers: isFormData ? {} : { "Content-Type": "application/json" },
+      body: isFormData ? data : JSON.stringify(data),
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error || "Failed to create broadcast");
+    }
+    return res.json();
+  },
+
+  deleteBroadcast: async (id: number): Promise<void> => {
+    const res = await fetch(`${API_BASE}/broadcasts/${id}`, {
+      method: "DELETE",
+    });
+    if (!res.ok) throw new Error("Failed to delete broadcast");
+  },
 };
diff --git a/package-lock.json b/package-lock.json
index bb39a68..140ffff 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,6 +16,7 @@
         "dayjs": "^1.11.19",
         "dotenv": "^16.4.7",
         "express": "^4.21.2",
+        "multer": "^2.0.2",
         "node-cron": "^3.0.3",
         "playwright": "^1.49.1",
         "sqlite-gui-node": "^1.2.0",
@@ -27,6 +28,7 @@
       "devDependencies": {
         "@types/better-sqlite3": "^7.6.12",
         "@types/express": "^5.0.0",
+        "@types/multer": "^2.0.0",
         "@types/node": "^22.10.2",
         "@types/node-cron": "^3.0.11",
         "@types/web-push": "^3.6.4",
@@ -3855,6 +3857,16 @@
       "license": "MIT",
       "peer": true
     },
+    "node_modules/@types/multer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@types/multer/-/multer-2.0.0.tgz",
+      "integrity": "sha512-C3Z9v9Evij2yST3RSBktxP9STm6OdMc5uR1xF1SGr98uv8dUlAL2hqwrZ3GVB3uyMyiegnscEK6PGtYvNrjTjw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/express": "*"
+      }
+    },
     "node_modules/@types/node": {
       "version": "22.19.5",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.5.tgz",
@@ -4486,6 +4498,12 @@
         "node": ">= 8"
       }
     },
+    "node_modules/append-field": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
+      "integrity": "sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==",
+      "license": "MIT"
+    },
     "node_modules/aproba": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz",
@@ -5009,9 +5027,19 @@
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
       "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
-      "dev": true,
       "license": "MIT"
     },
+    "node_modules/busboy": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz",
+      "integrity": "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==",
+      "dependencies": {
+        "streamsearch": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=10.16.0"
+      }
+    },
     "node_modules/bytes": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
@@ -5446,6 +5474,21 @@
       "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
       "license": "MIT"
     },
+    "node_modules/concat-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-2.0.0.tgz",
+      "integrity": "sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==",
+      "engines": [
+        "node >= 6.0"
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^3.0.2",
+        "typedarray": "^0.0.6"
+      }
+    },
     "node_modules/concurrently": {
       "version": "9.2.1",
       "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-9.2.1.tgz",
@@ -9261,6 +9304,36 @@
       "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
       "license": "MIT"
     },
+    "node_modules/multer": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/multer/-/multer-2.0.2.tgz",
+      "integrity": "sha512-u7f2xaZ/UG8oLXHvtF/oWTRvT44p9ecwBBqTwgJVq0+4BW1g8OW01TyMEGWBHbyMOYVHXslaut7qEQ1meATXgw==",
+      "license": "MIT",
+      "dependencies": {
+        "append-field": "^1.0.0",
+        "busboy": "^1.6.0",
+        "concat-stream": "^2.0.0",
+        "mkdirp": "^0.5.6",
+        "object-assign": "^4.1.1",
+        "type-is": "^1.6.18",
+        "xtend": "^4.0.2"
+      },
+      "engines": {
+        "node": ">= 10.16.0"
+      }
+    },
+    "node_modules/multer/node_modules/mkdirp": {
+      "version": "0.5.6",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
+      "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
+      "license": "MIT",
+      "dependencies": {
+        "minimist": "^1.2.6"
+      },
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      }
+    },
     "node_modules/nanoid": {
       "version": "3.3.11",
       "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
@@ -9557,7 +9630,6 @@
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
       "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -11260,6 +11332,14 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/streamsearch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz",
+      "integrity": "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
     "node_modules/string_decoder": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
@@ -12012,6 +12092,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==",
+      "license": "MIT"
+    },
     "node_modules/typescript": {
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
@@ -13345,6 +13431,15 @@
         }
       }
     },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
     "node_modules/y18n": {
       "version": "5.0.8",
       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
diff --git a/package.json b/package.json
index 80052c9..883d3a5 100644
--- a/package.json
+++ b/package.json
@@ -32,6 +32,7 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.12",
     "@types/express": "^5.0.0",
+    "@types/multer": "^2.0.0",
     "@types/node": "^22.10.2",
     "@types/node-cron": "^3.0.11",
     "@types/web-push": "^3.6.4",
@@ -49,6 +50,7 @@
     "dayjs": "^1.11.19",
     "dotenv": "^16.4.7",
     "express": "^4.21.2",
+    "multer": "^2.0.2",
     "node-cron": "^3.0.3",
     "playwright": "^1.49.1",
     "sqlite-gui-node": "^1.2.0",
diff --git a/shared/types.ts b/shared/types.ts
index 70154e0..e174f07 100644
--- a/shared/types.ts
+++ b/shared/types.ts
@@ -1,8 +1,56 @@
 // Shared Types
 
 export interface Contact {
+  id: number;
   name: string;
-  phone?: string;
+  number: string;
+  email?: string;
+  companyName?: string;
+  createdAt: string;
+}
+
+export interface Broadcast {
+  id: number;
+  name: string;
+  message: string;
+  attachmentPath?: string;
+  attachmentName?: string;
+  status: "draft" | "scheduled" | "processing" | "completed" | "failed";
+  scheduledTime?: string;
+  type?: "instant" | "once" | "recurring";
+  intervalValue?: number;
+  intervalUnit?: "minute" | "hour" | "day" | "week" | "month";
+  nextRun?: string;
+  lastRun?: string;
+  createdAt: string;
+}
+
+export interface BroadcastRecipient {
+  id: number;
+  broadcastId: number;
+  contactId: number;
+  status: "pending" | "sent" | "failed";
+  sentAt?: string;
+  error?: string;
+}
+
+export interface CreateContactDto {
+  name: string;
+  number: string;
+  email?: string;
+  companyName?: string;
+}
+
+export interface CreateBroadcastDto {
+  name: string;
+  message: string;
+  attachmentPath?: string;
+  attachmentName?: string;
+  contactIds: number[];
+  scheduledTime?: string;
+  type?: "instant" | "once" | "recurring";
+  intervalValue?: number;
+  intervalUnit?: "minute" | "hour" | "day" | "week" | "month";
 }
 
 export interface Schedule {
diff --git a/src/api/broadcasts.ts b/src/api/broadcasts.ts
new file mode 100644
index 0000000..0665dde
--- /dev/null
+++ b/src/api/broadcasts.ts
@@ -0,0 +1,206 @@
+import { Router } from "express";
+import db from "../db/db.js";
+import { Broadcast, Contact } from "../../shared/types.js";
+import { createBroadcastSchema } from "../validations/broadcastSchemas.js";
+import { whatsappService } from "../services/whatsapp.js";
+import multer from "multer";
+import path from "path";
+import fs from "fs";
+
+const router = Router();
+
+// Setup multer for file uploads
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    const uploadDir = path.resolve("data/uploads");
+    if (!fs.existsSync(uploadDir)) {
+      fs.mkdirSync(uploadDir, { recursive: true });
+    }
+    cb(null, uploadDir);
+  },
+  filename: (req, file, cb) => {
+    cb(null, `${Date.now()}-${file.originalname}`);
+  },
+});
+
+const upload = multer({ storage });
+
+// GET all broadcasts
+router.get("/", (req, res) => {
+  try {
+    const stmt = db.prepare("SELECT * FROM broadcasts ORDER BY createdAt DESC");
+    const broadcasts = stmt.all() as Broadcast[];
+    res.json(broadcasts);
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET broadcast details
+router.get("/:id", (req, res) => {
+  const { id } = req.params;
+  try {
+    const broadcast = db
+      .prepare("SELECT * FROM broadcasts WHERE id = ?")
+      .get(id) as Broadcast;
+    if (!broadcast) {
+      return res.status(404).json({ error: "Broadcast not found" });
+    }
+
+    const recipients = db
+      .prepare(
+        `
+        SELECT br.*, c.name as contactName, c.number as contactNumber 
+        FROM broadcast_recipients br
+        JOIN contacts c ON br.contactId = c.id
+        WHERE br.broadcastId = ?
+     `
+      )
+      .all(id);
+
+    res.json({ ...broadcast, recipients });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// POST create broadcast
+router.post("/", upload.single("attachment"), async (req, res) => {
+  try {
+    // If contactIds is coming as a string (from FormData), parse it
+    if (typeof req.body.contactIds === "string") {
+      try {
+        req.body.contactIds = JSON.parse(req.body.contactIds);
+      } catch (e) {
+        // Fallback or ignore
+      }
+    }
+    // Convert numerical strings
+    if (req.body.intervalValue) {
+      req.body.intervalValue = parseInt(req.body.intervalValue);
+    }
+
+    const validation = createBroadcastSchema.safeParse(req.body);
+    if (!validation.success) {
+      return res
+        .status(400)
+        .json({ error: validation.error.issues[0].message });
+    }
+    const {
+      name,
+      message,
+      contactIds,
+      scheduledTime,
+      type,
+      intervalValue,
+      intervalUnit,
+    } = validation.data;
+
+    const attachmentPath = req.file ? req.file.path : null;
+    const attachmentName = req.file ? req.file.originalname : null;
+
+    let status = scheduledTime ? "scheduled" : "draft";
+    const broadcastType = type || (scheduledTime ? "once" : "instant");
+
+    if (broadcastType === "recurring") {
+      status = "scheduled";
+    } else if (broadcastType === "instant") {
+      status = "processing";
+    }
+
+    const trans = db.transaction(() => {
+      const stmt = db.prepare(
+        "INSERT INTO broadcasts (name, message, scheduledTime, status, type, intervalValue, intervalUnit, nextRun, attachmentPath, attachmentName) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      );
+      const nextRun = broadcastType === "recurring" ? scheduledTime : null;
+
+      const info = stmt.run(
+        name,
+        message,
+        scheduledTime || null,
+        status,
+        broadcastType,
+        intervalValue || null,
+        intervalUnit || null,
+        nextRun,
+        attachmentPath,
+        attachmentName
+      );
+      const broadcastId = info.lastInsertRowid;
+
+      const recipientStmt = db.prepare(
+        "INSERT INTO broadcast_recipients (broadcastId, contactId) VALUES (?, ?)"
+      );
+      for (const cid of contactIds) {
+        recipientStmt.run(broadcastId, cid);
+      }
+      return broadcastId;
+    });
+
+    const id = trans();
+    const newBroadcast = db
+      .prepare("SELECT * FROM broadcasts WHERE id = ?")
+      .get(id);
+
+    // Send immediately if instant
+    if (broadcastType === "instant") {
+      const placeholders = contactIds.map(() => "?").join(",");
+      const contacts = db
+        .prepare(`SELECT * FROM contacts WHERE id IN (${placeholders})`)
+        .all(...contactIds) as Contact[];
+
+      console.log(
+        `Processing instant broadcast ${id} for ${contacts.length} contacts...`
+      );
+
+      (async () => {
+        for (const contact of contacts) {
+          try {
+            await whatsappService.sendMessageUnsaved(
+              contact.number,
+              message,
+              attachmentPath || undefined,
+              attachmentName || undefined
+            );
+            db.prepare(
+              "UPDATE broadcast_recipients SET status = 'sent', sentAt = CURRENT_TIMESTAMP WHERE broadcastId = ? AND contactId = ?"
+            ).run(id, contact.id);
+          } catch (err: any) {
+            console.error(
+              `Failed to send broadcast ${id} to ${contact.number}:`,
+              err
+            );
+            db.prepare(
+              "UPDATE broadcast_recipients SET status = 'failed', error = ? WHERE broadcastId = ? AND contactId = ?"
+            ).run(err.message, id, contact.id);
+          }
+        }
+        db.prepare(
+          "UPDATE broadcasts SET status = 'completed' WHERE id = ?"
+        ).run(id);
+      })();
+    }
+
+    res.status(201).json(newBroadcast);
+  } catch (err: any) {
+    console.error("Broadcast creation error:", err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// DELETE broadcast
+router.delete("/:id", (req, res) => {
+  const { id } = req.params;
+  try {
+    const stmt = db.prepare("DELETE FROM broadcasts WHERE id = ?");
+    const info = stmt.run(id);
+    if (info.changes === 0) {
+      return res.status(404).json({ error: "Broadcast not found" });
+    }
+    res.json({ success: true });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;
diff --git a/src/api/contacts.ts b/src/api/contacts.ts
new file mode 100644
index 0000000..7694f69
--- /dev/null
+++ b/src/api/contacts.ts
@@ -0,0 +1,117 @@
+import { Router } from "express";
+import db from "../db/db.js";
+import { Contact } from "../../shared/types.js";
+import { createContactSchema } from "../validations/contactSchemas.js";
+
+const router = Router();
+
+// GET all contacts
+router.get("/", (req, res) => {
+  try {
+    const stmt = db.prepare("SELECT * FROM contacts ORDER BY name ASC");
+    const contacts = stmt.all() as Contact[];
+    res.json(contacts);
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// POST create contact
+router.post("/", (req, res) => {
+  const validation = createContactSchema.safeParse(req.body);
+  if (!validation.success) {
+    return res.status(400).json({ error: validation.error.issues[0].message });
+  }
+  const { name, number, email, companyName } = validation.data;
+
+  try {
+    const stmt = db.prepare(
+      "INSERT INTO contacts (name, number, email, companyName) VALUES (?, ?, ?, ?)"
+    );
+    const info = stmt.run(name, number, email || null, companyName || null);
+    const newContact = db
+      .prepare("SELECT * FROM contacts WHERE id = ?")
+      .get(info.lastInsertRowid);
+    res.status(201).json(newContact);
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// POST bulk create contacts
+router.post("/bulk", (req, res) => {
+  const contacts = req.body;
+  if (!Array.isArray(contacts)) {
+    return res
+      .status(400)
+      .json({ error: "Input must be an array of contacts" });
+  }
+
+  try {
+    const results = {
+      success: 0,
+      failed: 0,
+      errors: [] as string[],
+    };
+
+    const stmt = db.prepare(
+      "INSERT INTO contacts (name, number, email, companyName) VALUES (?, ?, ?, ?)"
+    );
+
+    const transaction = db.transaction((data: any[]) => {
+      for (const contact of data) {
+        const validation = createContactSchema.safeParse(contact);
+        if (validation.success) {
+          try {
+            const { name, number, email, companyName } = validation.data;
+            stmt.run(name, number, email || null, companyName || null);
+            results.success++;
+          } catch (e: any) {
+            results.failed++;
+            results.errors.push(`Row error: ${e.message}`);
+          }
+        } else {
+          results.failed++;
+          results.errors.push(
+            `Validation error for ${contact.name || "unknown"}: ${
+              validation.error.issues[0].message
+            }`
+          );
+        }
+      }
+    });
+
+    transaction(contacts);
+    res.json(results);
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// DELETE all contacts
+router.delete("/", (req, res) => {
+  try {
+    const stmt = db.prepare("DELETE FROM contacts");
+    const info = stmt.run();
+    res.json({ success: true, deletedCount: info.changes });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// DELETE contact
+router.delete("/:id", (req, res) => {
+  const { id } = req.params;
+  try {
+    const stmt = db.prepare("DELETE FROM contacts WHERE id = ?");
+    const info = stmt.run(id);
+    if (info.changes === 0) {
+      return res.status(404).json({ error: "Contact not found" });
+    }
+    res.json({ success: true });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;
diff --git a/src/db/migrations.ts b/src/db/migrations.ts
index b50fa87..d1d0f55 100644
--- a/src/db/migrations.ts
+++ b/src/db/migrations.ts
@@ -81,79 +81,83 @@ export function runMigrations(db: Database.Database) {
 
     // Check if 'paused' status is supported
     try {
-      db.exec("BEGIN TRANSACTION");
-      const testStmt = db.prepare(
-        "INSERT INTO schedules (type, contactName, message, status) VALUES ('once', 'test', 'test', 'paused')"
-      );
-      try {
-        testStmt.run();
-        db.exec("ROLLBACK");
-      } catch (e: any) {
-        db.exec("ROLLBACK");
-        if (e.message && e.message.includes("CHECK constraint failed")) {
-          console.log(
-            "Detected missing 'paused' status support. Migrating schedules table while PRESERVING data..."
-          );
-
-          // 1. Rename existing table
-          db.exec("ALTER TABLE schedules RENAME TO schedules_old");
-
-          // 2. Create new table with updated schema (defined below in main block, but we need it now to copy)
-          db.exec(`
-            CREATE TABLE IF NOT EXISTS schedules (
-              id INTEGER PRIMARY KEY AUTOINCREMENT,
-              type TEXT NOT NULL CHECK(type IN ('instant', 'once', 'recurring')),
-              contactName TEXT NOT NULL,
-              message TEXT NOT NULL,
-              scheduleTime TEXT,
-              status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('pending', 'active', 'completed', 'failed', 'cancelled', 'paused')),
-              lastRun TEXT,
-              nextRun TEXT,
-              createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
-              intervalValue INTEGER,
-              intervalUnit TEXT,
-              toleranceMinutes INTEGER
+      // Ensure table exists first
+      const schInfo = db.prepare("PRAGMA table_info(schedules)").all() as any[];
+      if (schInfo.length > 0) {
+        db.exec("BEGIN TRANSACTION");
+        const testStmt = db.prepare(
+          "INSERT INTO schedules (type, contactName, message, status) VALUES ('once', 'test', 'test', 'paused')"
+        );
+        try {
+          testStmt.run();
+          db.exec("ROLLBACK");
+        } catch (e: any) {
+          db.exec("ROLLBACK");
+          if (e.message && e.message.includes("CHECK constraint failed")) {
+            console.log(
+              "Detected missing 'paused' status support. Migrating schedules table while PRESERVING data..."
             );
-          `);
 
-          // 3. Copy data from old table to new table
-          db.exec(`
-            INSERT INTO schedules (id, type, contactName, message, scheduleTime, status, lastRun, nextRun, createdAt, intervalValue, intervalUnit, toleranceMinutes)
-            SELECT id, type, contactName, message, scheduleTime, status, lastRun, nextRun, createdAt, intervalValue, intervalUnit, toleranceMinutes
-            FROM schedules_old
-          `);
+            // 1. Rename existing table
+            db.exec("ALTER TABLE schedules RENAME TO schedules_old");
 
-          // 4. Update foreign keys in message_logs
-          // SQLite creates an implicit reference to the renamed table (schedules_old) when renaming.
-          // We MUST recreate message_logs to point to the new 'schedules' table.
-          db.exec("ALTER TABLE message_logs RENAME TO message_logs_old");
+            // 2. Create new table with updated schema (defined below in main block, but we need it now to copy)
+            db.exec(`
+              CREATE TABLE IF NOT EXISTS schedules (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                type TEXT NOT NULL CHECK(type IN ('instant', 'once', 'recurring')),
+                contactName TEXT NOT NULL,
+                message TEXT NOT NULL,
+                scheduleTime TEXT,
+                status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('pending', 'active', 'completed', 'failed', 'cancelled', 'paused')),
+                lastRun TEXT,
+                nextRun TEXT,
+                createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+                intervalValue INTEGER,
+                intervalUnit TEXT,
+                toleranceMinutes INTEGER
+              );
+            `);
 
-          db.exec(`
-            CREATE TABLE IF NOT EXISTS message_logs (
-              id INTEGER PRIMARY KEY AUTOINCREMENT,
-              scheduleId INTEGER,
-              type TEXT NOT NULL CHECK(type IN ('instant', 'once', 'recurring')),
-              contactName TEXT NOT NULL,
-              message TEXT NOT NULL,
-              status TEXT NOT NULL CHECK(status IN ('sending', 'sent', 'failed')),
-              timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
-              error TEXT,
-              FOREIGN KEY (scheduleId) REFERENCES schedules(id) ON DELETE CASCADE
-            );
-          `);
+            // 3. Copy data from old table to new table
+            db.exec(`
+              INSERT INTO schedules (id, type, contactName, message, scheduleTime, status, lastRun, nextRun, createdAt, intervalValue, intervalUnit, toleranceMinutes)
+              SELECT id, type, contactName, message, scheduleTime, status, lastRun, nextRun, createdAt, intervalValue, intervalUnit, toleranceMinutes
+              FROM schedules_old
+            `);
 
-          db.exec(`
-            INSERT INTO message_logs (id, scheduleId, type, contactName, message, status, timestamp, error)
-            SELECT id, scheduleId, type, contactName, message, status, timestamp, error
-            FROM message_logs_old
-          `);
+            // 4. Update foreign keys in message_logs
+            // SQLite creates an implicit reference to the renamed table (schedules_old) when renaming.
+            // We MUST recreate message_logs to point to the new 'schedules' table.
+            db.exec("ALTER TABLE message_logs RENAME TO message_logs_old");
+
+            db.exec(`
+              CREATE TABLE IF NOT EXISTS message_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                scheduleId INTEGER,
+                type TEXT NOT NULL CHECK(type IN ('instant', 'once', 'recurring')),
+                contactName TEXT NOT NULL,
+                message TEXT NOT NULL,
+                status TEXT NOT NULL CHECK(status IN ('sending', 'sent', 'failed')),
+                timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+                error TEXT,
+                FOREIGN KEY (scheduleId) REFERENCES schedules(id) ON DELETE CASCADE
+              );
+            `);
+
+            db.exec(`
+              INSERT INTO message_logs (id, scheduleId, type, contactName, message, status, timestamp, error)
+              SELECT id, scheduleId, type, contactName, message, status, timestamp, error
+              FROM message_logs_old
+            `);
 
-          db.exec("DROP TABLE message_logs_old");
+            db.exec("DROP TABLE message_logs_old");
 
-          // 5. Drop old table
-          db.exec("DROP TABLE schedules_old");
+            // 5. Drop old table
+            db.exec("DROP TABLE schedules_old");
 
-          console.log("Migration completed. Data preserved.");
+            console.log("Migration completed. Data preserved.");
+          }
         }
       }
     } catch (e) {
@@ -223,5 +227,112 @@ export function runMigrations(db: Database.Database) {
     );
   `);
 
+  // Schema migration for contacts table (add companyName)
+  try {
+    const contactsInfo = db
+      .prepare("PRAGMA table_info(contacts)")
+      .all() as any[];
+    // Only verify if table exists
+    if (contactsInfo.length > 0) {
+      const hasCompany = contactsInfo.some((col) => col.name === "companyName");
+      if (!hasCompany) {
+        console.log("Adding companyName column to contacts...");
+        db.exec("ALTER TABLE contacts ADD COLUMN companyName TEXT");
+      }
+    }
+  } catch (err) {
+    console.warn("Error migrating contacts schema:", err);
+  }
+
+  // Contacts Table
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS contacts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      number TEXT NOT NULL,
+      email TEXT,
+      companyName TEXT,
+      createdAt TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+
+  // Broadcasts Schema Migration
+  try {
+    const broadcastsInfo = db
+      .prepare("PRAGMA table_info(broadcasts)")
+      .all() as any[];
+    if (broadcastsInfo.length > 0) {
+      const hasType = broadcastsInfo.some((col) => col.name === "type");
+      if (!hasType) {
+        console.log("Adding recurrence columns to broadcasts...");
+        db.exec("ALTER TABLE broadcasts ADD COLUMN type TEXT DEFAULT 'once'");
+        db.exec("ALTER TABLE broadcasts ADD COLUMN intervalValue INTEGER");
+        db.exec("ALTER TABLE broadcasts ADD COLUMN intervalUnit TEXT");
+        db.exec("ALTER TABLE broadcasts ADD COLUMN nextRun TEXT");
+        db.exec("ALTER TABLE broadcasts ADD COLUMN lastRun TEXT");
+      }
+    }
+  } catch (err) {
+    console.warn("Error migrating broadcasts schema:", err);
+  }
+
+  // Add attachmentPath migration
+  try {
+    const broadcastsInfo = db
+      .prepare("PRAGMA table_info(broadcasts)")
+      .all() as any[];
+    if (broadcastsInfo.length > 0) {
+      const hasAttachment = broadcastsInfo.some(
+        (col) => col.name === "attachmentPath"
+      );
+      if (!hasAttachment) {
+        console.log("Adding attachmentPath column to broadcasts...");
+        db.exec("ALTER TABLE broadcasts ADD COLUMN attachmentPath TEXT");
+      }
+      const hasAttachmentName = broadcastsInfo.some(
+        (col) => col.name === "attachmentName"
+      );
+      if (!hasAttachmentName) {
+        console.log("Adding attachmentName column to broadcasts...");
+        db.exec("ALTER TABLE broadcasts ADD COLUMN attachmentName TEXT");
+      }
+    }
+  } catch (err) {
+    console.warn("Error migrating broadcasts attachment schema:", err);
+  }
+
+  // Broadcasts Table
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS broadcasts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      message TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'draft' CHECK(status IN ('draft', 'scheduled', 'processing', 'completed', 'failed')),
+      scheduledTime TEXT,
+      type TEXT DEFAULT 'once',
+      intervalValue INTEGER,
+      intervalUnit TEXT,
+      nextRun TEXT,
+      lastRun TEXT,
+      attachmentPath TEXT,
+      attachmentName TEXT,
+      createdAt TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+
+  // Broadcast Recipients Link Table
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS broadcast_recipients (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      broadcastId INTEGER NOT NULL,
+      contactId INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'sent', 'failed')),
+      sentAt TEXT,
+      error TEXT,
+      FOREIGN KEY (broadcastId) REFERENCES broadcasts(id) ON DELETE CASCADE,
+      FOREIGN KEY (contactId) REFERENCES contacts(id) ON DELETE CASCADE
+    );
+  `);
+
   console.log("Migrations applied successfully.");
 }
diff --git a/src/server.ts b/src/server.ts
index 065e1c2..028bd61 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -39,6 +39,12 @@ app.use("/api/whatsapp", whatsappRouter);
 import notificationsRouter from "./api/notifications.js";
 app.use("/api/notifications", notificationsRouter);
 
+import contactsRouter from "./api/contacts.js";
+app.use("/api/contacts", contactsRouter);
+
+import broadcastsRouter from "./api/broadcasts.js";
+app.use("/api/broadcasts", broadcastsRouter);
+
 import historyRouter from "./api/history.js";
 app.use("/api/history", historyRouter);
 
diff --git a/src/services/scheduler.ts b/src/services/scheduler.ts
index b56939a..81eb4d2 100644
--- a/src/services/scheduler.ts
+++ b/src/services/scheduler.ts
@@ -1,5 +1,5 @@
 import cron from "node-cron";
-import { Schedule } from "../../shared/types.js";
+import { Broadcast, Contact, Schedule } from "../../shared/types.js";
 import db from "../db/db.js";
 import { whatsappService } from "./whatsapp.js";
 
@@ -14,6 +14,7 @@ class SchedulerService {
     // Check schedules every minute (heartbeat)
     cron.schedule("* * * * *", () => {
       this.checkSchedules();
+      this.checkBroadcasts();
     });
   }
 
@@ -271,6 +272,8 @@ class SchedulerService {
       await whatsappService.sendMessage(
         schedule.contactName,
         schedule.message,
+        undefined, // attachmentPath
+        undefined, // attachmentName
         logId
       );
 
@@ -347,6 +350,97 @@ class SchedulerService {
       "UPDATE message_logs SET status = ?, error = ? WHERE id = ?"
     ).run(status, error || null, logId);
   }
+
+  async checkBroadcasts() {
+    const status = whatsappService.getStatus();
+    if (!status.authenticated) return;
+
+    const now = new Date();
+    const nowIso = now.toISOString();
+
+    // Find active broadcasts due for execution
+    const broadcasts = db
+      .prepare(
+        "SELECT * FROM broadcasts WHERE status = 'scheduled' AND ((type = 'once' AND scheduledTime <= ?) OR (type = 'recurring' AND nextRun <= ?))"
+      )
+      .all(nowIso, nowIso) as Broadcast[];
+
+    for (const b of broadcasts) {
+      console.log(`Processing scheduled broadcast ${b.id}: ${b.name}`);
+
+      // Update status to processing to prevent double execution
+      db.prepare(
+        "UPDATE broadcasts SET status = 'processing' WHERE id = ?"
+      ).run(b.id);
+
+      const recipients = db
+        .prepare(
+          `
+        SELECT c.* FROM broadcast_recipients br
+        JOIN contacts c ON br.contactId = c.id
+        WHERE br.broadcastId = ? AND br.status = 'pending'
+      `
+        )
+        .all(b.id) as Contact[];
+
+      (async () => {
+        for (const contact of recipients) {
+          try {
+            await whatsappService.sendMessageUnsaved(
+              contact.number,
+              b.message,
+              b.attachmentPath || undefined,
+              b.attachmentName || undefined
+            );
+            db.prepare(
+              "UPDATE broadcast_recipients SET status = 'sent', sentAt = CURRENT_TIMESTAMP WHERE broadcastId = ? AND contactId = ?"
+            ).run(b.id, contact.id);
+          } catch (err: any) {
+            console.error(
+              `Failed to send broadcast ${b.id} to ${contact.number}:`,
+              err
+            );
+            db.prepare(
+              "UPDATE broadcast_recipients SET status = 'failed', error = ? WHERE broadcastId = ? AND contactId = ?"
+            ).run(err.message, b.id, contact.id);
+          }
+        }
+
+        // Update broadcast status and handle recurrence
+        const updatedStatus =
+          b.type === "recurring" ? "scheduled" : "completed";
+        const lastRun = new Date().toISOString();
+        let nextRun = null;
+
+        if (b.type === "recurring" && b.intervalValue && b.intervalUnit) {
+          // Calculate next run
+          const nextDate = new Date();
+          switch (b.intervalUnit) {
+            case "minute":
+              nextDate.setMinutes(nextDate.getMinutes() + b.intervalValue);
+              break;
+            case "hour":
+              nextDate.setHours(nextDate.getHours() + b.intervalValue);
+              break;
+            case "day":
+              nextDate.setDate(nextDate.getDate() + b.intervalValue);
+              break;
+            case "week":
+              nextDate.setDate(nextDate.getDate() + b.intervalValue * 7);
+              break;
+            case "month":
+              nextDate.setMonth(nextDate.getMonth() + b.intervalValue);
+              break;
+          }
+          nextRun = nextDate.toISOString();
+        }
+
+        db.prepare(
+          "UPDATE broadcasts SET status = ?, lastRun = ?, nextRun = ? WHERE id = ?"
+        ).run(updatedStatus, lastRun, nextRun, b.id);
+      })();
+    }
+  }
 }
 
 export const schedulerService = new SchedulerService();
diff --git a/src/services/whatsapp.ts b/src/services/whatsapp.ts
index 768d3aa..1048509 100644
--- a/src/services/whatsapp.ts
+++ b/src/services/whatsapp.ts
@@ -107,6 +107,7 @@ export class WhatsAppService {
       USER_DATA_DIR,
       {
         headless: true,
+        permissions: ["clipboard-read", "clipboard-write"],
         viewport: null,
         userAgent:
           "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
@@ -403,6 +404,37 @@ export class WhatsAppService {
     }
   }
 
+  async openChatUnsaved(contactNo: string): Promise<void> {
+    if (!this.page) throw new Error("Page not initialized");
+
+    console.log(`Opening unsaved chat: ${contactNo}`);
+    const newChatBtnSelector = 'button[aria-label="New chat"]';
+    const searchInputSelector = 'div[aria-label="Search name or number"]';
+    const composerSelector = "div[contenteditable='true'][data-tab]";
+
+    try {
+      await this.page.waitForSelector(newChatBtnSelector, { timeout: 1000 });
+      await this.page.click(newChatBtnSelector);
+
+      await this.page.waitForSelector(searchInputSelector, { timeout: 1000 });
+
+      await this.page.click(searchInputSelector);
+      await delay(500);
+      await this.page.keyboard.type(contactNo);
+
+      // Click the search result instead of pressing Enter
+      const contactSelector = 'div[data-tab="4"][role="button"]';
+      await this.page.waitForSelector(contactSelector, { timeout: 2000 });
+      await this.page.click(contactSelector);
+
+      await this.page.waitForSelector(composerSelector, { timeout: 20000 });
+      console.log(`Unsaved chat opened: ${contactNo}`);
+    } catch (err) {
+      console.error(`Failed to open unsaved chat '${contactNo}':`, err);
+      throw err;
+    }
+  }
+
   private async waitUntilTargetSecond(): Promise<void> {
     // Check if configuration is valid (0-59)
     if (BROWSER_CLOSE_TARGET_SECOND < 0 || BROWSER_CLOSE_TARGET_SECOND > 59) {
@@ -453,6 +485,8 @@ export class WhatsAppService {
   async sendMessage(
     contactName: string,
     message: string,
+    attachmentPath?: string,
+    attachmentName?: string,
     logId?: number | bigint
   ): Promise<void> {
     console.log(`Attempting to send message to contact: ${contactName}`);
@@ -499,13 +533,73 @@ export class WhatsAppService {
       // Type and send the message
       await delay(400 + Math.random() * 800);
       // Clear any existing text first
-      await this.page.keyboard.press("Control+A");
+      // Clear any existing text first
+      const isMac = process.platform === "darwin";
+      const modifier = isMac ? "Meta" : "Control";
+
+      await this.page.keyboard.press(`${modifier}+A`);
       await this.page.keyboard.press("Backspace");
       await delay(200);
 
-      await this.page.keyboard.type(message);
-      await this.page.keyboard.press("Enter");
-      await delay(2000);
+      // Copy to clipboard and paste to preserve formatting and prevent newlines from sending
+      await this.page.evaluate(async (text) => {
+        await navigator.clipboard.writeText(text);
+      }, message);
+      await delay(200);
+
+      await this.page.keyboard.press(`${modifier}+V`);
+      await delay(500); // Wait for paste to complete
+
+      if (attachmentPath) {
+        console.log(
+          `Attaching file: ${attachmentPath}${attachmentName ? ` as ${attachmentName}` : ""}`
+        );
+        const fileBuffer = fs.readFileSync(attachmentPath);
+        const fileName = attachmentName || path.basename(attachmentPath);
+        const extension = path.extname(fileName).toLowerCase();
+
+        // Simple mime type map
+        const mimeTypes: { [key: string]: string } = {
+          ".png": "image/png",
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".gif": "image/gif",
+          ".pdf": "application/pdf",
+          ".mp4": "video/mp4",
+          ".mp3": "audio/mpeg",
+          ".csv": "text/csv",
+          ".txt": "text/plain",
+          ".docx":
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+          ".xlsx":
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        };
+        const mimeType = mimeTypes[extension] || "application/octet-stream";
+
+        await this.page.evaluate(
+          async ({ buffer, name, type }) => {
+            const blob = new Blob([new Uint8Array(buffer)], { type });
+            const file = new File([blob], name, { type });
+            const dataTransfer = new DataTransfer();
+            dataTransfer.items.add(file);
+            const event = new ClipboardEvent("paste", {
+              clipboardData: dataTransfer,
+              bubbles: true,
+              cancelable: true,
+            });
+            document.activeElement?.dispatchEvent(event);
+          },
+          { buffer: Array.from(fileBuffer), name: fileName, type: mimeType }
+        );
+
+        console.log("Waiting for attachment to load...");
+        await delay(3000); // Wait for attachment to process
+        await this.page.keyboard.press("Enter");
+        await delay(2000);
+      } else {
+        await this.page.keyboard.press("Enter");
+        await delay(2000);
+      }
 
       // Wait for message to be sent (status != 'Pending')
       // Using locator API as requested: verify last message's status icon
@@ -577,14 +671,190 @@ export class WhatsAppService {
         }
       }
 
-      await this.waitUntilTargetSecond(); // Wait before closing on error too? Usually safer to keep pattern consistent or fail fast.
-      // Requirement: "from the moment a task starts... it should remain open untill thr 55th second... It can exceed that if need be"
-      // So yes, even on error we should hypothetically wait, but often errors need fast feedback.
-      // However, "fail fast" usually wins. But let's stick to valid "task starts... keep browser open".
-      // Let's apply it to success path first and foremost. For error, maybe better to close fast?
-      // Re-reading: "make sure that from the moment a task starts... it is done with its stuff before that it should still keep the browser open"
-      // If it fails, it's technically "done with its stuff".
-      // I'll add it to the error path as well for consistency, unless user complains.
+      // Skip wait on error
+
+      // Close browser immediately on failure
+
+      await this.closeBrowser();
+      throw err;
+    }
+  }
+
+  async sendMessageUnsaved(
+    contactNo: string,
+    message: string,
+    attachmentPath?: string,
+    attachmentName?: string,
+    logId?: number | bigint
+  ): Promise<void> {
+    console.log(`Attempting to send message to unsaved contact: ${contactNo}`);
+
+    // Check if tracing is enabled
+    let tracingEnabled = false;
+    try {
+      const setting = db
+        .prepare("SELECT value FROM settings WHERE key = 'enable_tracing'")
+        .get() as { value: string } | undefined;
+      tracingEnabled = setting?.value === "true";
+    } catch (err) {
+      console.error("Failed to check tracing setting:", err);
+    }
+
+    try {
+      await this.openBrowser();
+
+      // Check if still logged in
+      const isAuth = await this.isLoggedIn();
+      if (!isAuth) {
+        console.error("Not authenticated - QR code detected");
+        this.saveStatus(false);
+        await this.closeBrowser();
+        throw new Error("WhatsApp session expired - please reconnect");
+      }
+
+      if (!this.page) throw new Error("Driver not initialized");
+      await this.ensureReady();
+
+      // Open the target chat
+      await this.openChatUnsaved(contactNo);
+
+      // Start tracing if enabled and context is available
+      if (tracingEnabled && this.browserContext) {
+        console.log(`Starting trace for logId: ${logId}`);
+        await this.browserContext.tracing.start({
+          screenshots: true,
+          snapshots: true,
+          sources: true,
+        });
+      }
+
+      // Type and send the message
+      await delay(400 + Math.random() * 800);
+      // Clear any existing text first
+      // Clear any existing text first
+      const isMac = process.platform === "darwin";
+      const modifier = isMac ? "Meta" : "Control";
+
+      await this.page.keyboard.press(`${modifier}+A`);
+      await this.page.keyboard.press("Backspace");
+      await delay(200);
+
+      // Copy to clipboard and paste to preserve formatting and prevent newlines from sending
+      await this.page.evaluate(async (text) => {
+        await navigator.clipboard.writeText(text);
+      }, message);
+      await delay(200);
+
+      await this.page.keyboard.press(`${modifier}+V`);
+      await delay(500); // Wait for paste to complete
+
+      if (attachmentPath) {
+        console.log(
+          `Attaching file: ${attachmentPath}${attachmentName ? ` as ${attachmentName}` : ""}`
+        );
+        const fileBuffer = fs.readFileSync(attachmentPath);
+        const fileName = attachmentName || path.basename(attachmentPath);
+        const extension = path.extname(fileName).toLowerCase();
+
+        const mimeTypes: { [key: string]: string } = {
+          ".png": "image/png",
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".gif": "image/gif",
+          ".pdf": "application/pdf",
+          ".mp4": "video/mp4",
+          ".mp3": "audio/mpeg",
+          ".csv": "text/csv",
+          ".txt": "text/plain",
+          ".docx":
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+          ".xlsx":
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        };
+        const mimeType = mimeTypes[extension] || "application/octet-stream";
+
+        await this.page.evaluate(
+          async ({ buffer, name, type }) => {
+            const blob = new Blob([new Uint8Array(buffer)], { type });
+            const file = new File([blob], name, { type });
+            const dataTransfer = new DataTransfer();
+            dataTransfer.items.add(file);
+            const event = new ClipboardEvent("paste", {
+              clipboardData: dataTransfer,
+              bubbles: true,
+              cancelable: true,
+            });
+            document.activeElement?.dispatchEvent(event);
+          },
+          { buffer: Array.from(fileBuffer), name: fileName, type: mimeType }
+        );
+
+        console.log("Waiting for attachment to load...");
+        await delay(3000); // Wait for attachment to process
+        await this.page.keyboard.press("Enter");
+        await delay(2000);
+      } else {
+        await this.page.keyboard.press("Enter");
+        await delay(2000);
+      }
+
+      // Wait for message to be sent (status != 'Pending')
+      console.log("Waiting for message status to update from Pending...");
+      await this.page
+        .waitForFunction(
+          () => {
+            const allMessages = document.querySelectorAll(".message-out");
+            const lastMessage = allMessages[allMessages.length - 1];
+            if (!lastMessage) {
+              console.log("[WaitForFunction] No .message-out elements found");
+              return false;
+            }
+
+            const svg = lastMessage.querySelector("svg");
+            // The status icon container is the parent of the SVG
+            const statusContainer = svg?.parentElement;
+
+            if (!statusContainer) {
+              return false;
+            }
+
+            const label = statusContainer.getAttribute("aria-label");
+            return label && label.trim() !== "Pending";
+          },
+          null, // No arguments passed
+          { timeout: 20000 }
+        )
+        .catch((err) => {
+          throw new Error(
+            `Message status verification timed out: ${err.message}. This likely means the message remained 'Pending' or wasn't found.`
+          );
+        });
+
+      // Return to default chat instead of chat list
+      await this.returnToDefaultChat();
+
+      console.log("Message sent successfully to unsaved contact");
+
+      if (tracingEnabled && this.browserContext && logId) {
+        const tracePath = path.join(TRACES_DIR, `trace_${logId}.zip`);
+        await this.browserContext.tracing.stop({ path: tracePath });
+        console.log(`Trace saved to: ${tracePath}`);
+      }
+
+      await this.waitUntilTargetSecond();
+      await this.closeBrowser();
+    } catch (err: any) {
+      console.error("Failed to send message to unsaved contact:", err);
+
+      if (tracingEnabled && this.browserContext && logId) {
+        try {
+          const tracePath = path.join(TRACES_DIR, `trace_${logId}.zip`);
+          await this.browserContext.tracing.stop({ path: tracePath });
+          console.log(`Trace saved to: ${tracePath} (after failure)`);
+        } catch (traceErr) {
+          console.error("Failed to save trace after error:", traceErr);
+        }
+      }
 
       await this.closeBrowser();
       throw err;
diff --git a/src/validations/broadcastSchemas.ts b/src/validations/broadcastSchemas.ts
new file mode 100644
index 0000000..2039dc4
--- /dev/null
+++ b/src/validations/broadcastSchemas.ts
@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+export const createBroadcastSchema = z.object({
+  name: z.string().min(1, "Broadcast name is required"),
+  message: z.string().min(1, "Message is required"),
+  attachmentPath: z.string().optional().nullable(),
+  contactIds: z.array(z.number()).min(1, "At least one contact is required"),
+  scheduledTime: z.string().optional().nullable(),
+  type: z.enum(["instant", "once", "recurring"]).optional(),
+  intervalValue: z.number().optional(),
+  intervalUnit: z.enum(["minute", "hour", "day", "week", "month"]).optional(),
+});
+
+export type CreateBroadcastSchema = z.infer<typeof createBroadcastSchema>;
diff --git a/src/validations/contactSchemas.ts b/src/validations/contactSchemas.ts
new file mode 100644
index 0000000..7471b55
--- /dev/null
+++ b/src/validations/contactSchemas.ts
@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const createContactSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  number: z.string().min(1, "Number is required"),
+  email: z.string().email().optional().nullable().or(z.literal("")),
+  companyName: z.string().optional().nullable(),
+});
+
+export type CreateContactSchema = z.infer<typeof createContactSchema>;