DEV Community: Antigravity Dev Studio

كيف تبني متجر واتساب إلكتروني ونظام عروض أسعار وفواتير متكامل بلغة بايثون بدون اشتراكات شهرية

Antigravity Dev Studio — Sun, 01 Nov 2026 17:47:57 +0000

في بيئة الأعمال الرقمية والتجارة الإلكترونية المعاصرة، يجد أصحاب المشاريع الصغيرة والمستقلون في العالم العربي أنفسهم محاصرين باشتراكات شهرية متراكمة (منصات المتاجر، أدوات الفواتير الإلكترونية، بوابات التوقيع الرقمي، ومزودو خدمة واتساب)، مما يبتلع جزءاً كبيراً من هوامش الربح قبل حتى تحقيق أول عملية بيع حقيقية.

والأخطر من ذلك هو ارتهان بيانات العملاء وقوائم الطلبات والتقارير المالية لخوادم ومنصات وسيطة تفرض شروطها وتزيد أسعارها دورياً.

في هذا الدليل الهندسي والعملي من استوديو أنتيجرافيتي (Antigravity Dev Studio)، سنستعرض بالتفصيل كيف تبني منصة تجارة إلكترونية كاملة تعتمد على واتساب، بالإضافة إلى نظام عروض أسعار وفواتير رسمية قابلة للطباعة PDF، باستخدام مكتبة بايثون القياسية (Python Standard Library) وقواعد بيانات SQLite المدمجة، بدون الحاجة لتثبيت أي حزمة خارجية من pip، وبدون دفع دولار واحد كاشتراك شهري متكرر.

1. نموذج العمل: لماذا واتساب + بايثون النقي؟

في الأسواق العربية (السعودية، الإمارات، مصر، الخليج العربي وشمال إفريقيا)، يعتبر تطبيق واتساب الأداة الأكثر موثوقية والأعلى في معدلات التحويل (Conversion Rate). الزبائن يفضلون دائماً التأكيد المباشر والمحادثة الإنسانية على نماذج الدفع الإلكتروني الطويلة والمعقدة.

بدلاً من الاشتراك في منصات SaaS باهظة، قمنا في تطبيقنا OrderFlow Pro ببناء معمارية برمجية ترتكز على:

واجهة متجر سريعة للغاية (Single Page Application) بدون أطر عمل ثقيلة.
محرك سلة تسوق محلي يدعم الكوبونات وحساب رسوم التوصيل والضرائب.
مولد روابط واتساب ذكي يحول محتويات السلة وعنوان العميل وكود الطلب فوراً إلى رسالة منسقة وجاهزة للإرسال بضغطة زر واحدة.

إليك الكود المصدري الكامل والمجرب بلغة بايثون لتوليد رابط الطلب المباشر عبر واتساب:

import urllib.parse
from typing import Any, Dict, List

def generate_arabic_whatsapp_order_link(
    store_phone: str,
    order_code: str,
    customer_name: str,
    customer_phone: str,
    city: str,
    address: str,
    items: List[Dict[str, Any]],
    subtotal: float,
    discount: float,
    delivery_fee: float,
    total: float,
    currency: str = "SAR"
) -> str:
    """
    يقوم بإنشاء رابط ويب رسمي لتطبيق واتساب يحتوي على تفاصيل الطلب كاملة باللغة العربية.
    يعمل تلقائياً على أجهزة أندرويد، آيفون، وأجهزة الكمبيوتر.
    """
    # تنظيف رقم هاتف المتجر
    clean_phone = "".join(filter(str.isdigit, store_phone))

    # صياغة أسطر المنتجات
    lines = []
    for item in items:
        qty = item.get("qty", 1)
        name = item.get("name", "منتج")
        price = item.get("price", 0.0)
        lines.append(f"▫️ {qty}x {name} — {price * qty:,.2f} {currency}")

    items_text = "\n".join(lines)

    # الرسالة العربية المنسقة
    message = (
        f"🛍️ *طلب شراء جديد: #{order_code}*\n"
        f"━━━━━━━━━━━━━━━━━━\n"
        f"👤 *العميل:* {customer_name.strip()}\n"
        f"📱 *الجوال:* {customer_phone.strip()}\n"
        f"📍 *المدينة:* {city.strip()} - {address.strip()}\n\n"
        f"📦 *تفاصيل المنتجات:*\n"
        f"{items_text}\n\n"
        f"━━━━━━━━━━━━━━━━━━\n"
        f"💵 *المجموع الفرعي:* {subtotal:,.2f} {currency}\n"
    )

    if discount > 0:
        message += f"🏷️ *الخصم:* -{discount:,.2f} {currency}\n"

    message += (
        f"🚚 *التوصيل:* {delivery_fee:,.2f} {currency}\n"
        f"✅ *الإجمالي المستحق:* {total:,.2f} {currency}\n"
        f"━━━━━━━━━━━━━━━━━━\n"
        f"أرجو تأكيد الطلب وتحديد موعد الاستلام، شكراً لكم!"
    )

    # تشفير النص ليتوافق مع بروتوكول الروابط
    encoded_query = urllib.parse.quote(message)
    return f"https://wa.me/{clean_phone}?text={encoded_query}"

2. إدارة الفواتير وعروض الأسعار في بايثون: نمط SQLite WAL

أكبر مشكلة تواجه المطورين عند بناء أنظمة فواتير محلية هي تضارب المعاملات (Database Locked) وتكرار أرقام الفواتير المتسلسلة أثناء الضغط العالي.

الحل الهندسي الأفضل هو تفعيل نمط Write-Ahead Logging (WAL) في SQLite. هذا الوضع يفصل عمليات القراءة تماماً عن الكتابة، مما يسمح لمئات المستخدمين بتصفح المتجر وعروض الأسعار بالتوازي دون إبطاء عمليات حفظ الفواتير:

import contextlib
import datetime as dt
import sqlite3
from pathlib import Path

class ArabicInvoiceEngine:
    def __init__(self, db_path: str = "business.db"):
        self.db_path = Path(db_path)
        self._init_db()

    def _connect(self) -> sqlite3.Connection:
        conn = sqlite3.connect(str(self.db_path), timeout=15.0)
        conn.row_factory = sqlite3.Row
        # تفعيل نمط WAL وتطبيق القيود الخارجية
        conn.execute("PRAGMA journal_mode = WAL;")
        conn.execute("PRAGMA foreign_keys = ON;")
        conn.execute("PRAGMA synchronous = NORMAL;")
        return conn

    @contextlib.contextmanager
    def transaction(self):
        conn = self._connect()
        try:
            with conn: # يبدأ معاملة ذرية متسلسلة (Atomic Transaction)
                yield conn
        finally:
            conn.close()

    def _init_db(self):
        with self.transaction() as conn:
            conn.executescript("""
                CREATE TABLE IF NOT EXISTS invoices (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    invoice_code TEXT UNIQUE NOT NULL,
                    client_name TEXT NOT NULL,
                    client_phone TEXT NOT NULL,
                    total_amount REAL NOT NULL,
                    status TEXT NOT NULL DEFAULT 'UNPAID',
                    created_at TEXT NOT NULL
                );
            """)

    def create_invoice(self, client_name: str, client_phone: str, total_amount: float) -> str:
        year = dt.datetime.now(dt.timezone.utc).year
        now_str = dt.datetime.now(dt.timezone.utc).isoformat()
        prefix = f"INV-{year}-"

        with self.transaction() as conn:
            # استخراج أعلى رقم فاتورة مسجل خلال العام الحالي
            row = conn.execute(
                "SELECT invoice_code FROM invoices WHERE invoice_code LIKE ? ORDER BY id DESC LIMIT 1",
                (f"{prefix}%",)
            ).fetchone()

            next_id = 1
            if row:
                try:
                    next_id = int(row["invoice_code"].split("-")[-1]) + 1
                except ValueError:
                    pass

            code = f"{prefix}{next_id:04d}"
            conn.execute(
                """
                INSERT INTO invoices (invoice_code, client_name, client_phone, total_amount, created_at)
                VALUES (?, ?, ?, ?, ?)
                """,
                (code, client_name.strip(), client_phone.strip(), round(total_amount, 2), now_str)
            )
            return code

3. طباعة الفواتير باللغة العربية (RTL) إلى PDF بجودة متجهة فائقة

الكثير من المطورين يعانون عند استخدام مكتبات توليد PDF مثل reportlab أو weasyprint بسبب تشوه الخط العربي وانعكاس الحروف (تشابك الأحرف المعكوسة).

الحل الاحترافي الأبسط والأكثر استقراراً هو استخدام قوالب HTML5 النظيفة مع قواعد CSS @media print. محرك المتصفح الحديث يمتلك أفضل تقنية تشكيل خط عربي في العالم (Complex Text Layout)، وعند استدعاء أمر الطباعة window.print() ينتج ملف PDF متجهي فائق الدقة.

<!DOCTYPE html>
<html lang="ar" dir="rtl">
<head>
<meta charset="UTF-8">
<style>
  body {
    font-family: "Segoe UI", Tahoma, "Noto Sans Arabic", sans-serif;
    direction: rtl;
    text-align: right;
    background: #f8fafc;
    padding: 30px;
    color: #0f172a;
  }
  .invoice-box {
    max-width: 800px;
    margin: auto;
    background: #ffffff;
    padding: 40px;
    border-radius: 12px;
    box-shadow: 0 4px 20px rgba(0,0,0,0.06);
  }
  .invoice-header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    border-bottom: 2px solid #0f172a;
    padding-bottom: 20px;
  }
  table { width: 100%; border-collapse: collapse; margin-top: 25px; }
  th, td { padding: 12px; border-bottom: 1px solid #e2e8f0; text-align: right; }
  th { background: #f1f5f9; color: #475569; font-size: 13px; }
  .total-badge { font-size: 22px; font-weight: 900; color: #059669; }

  @media print {
    body { background: none; padding: 0; }
    .invoice-box { box-shadow: none; border-radius: 0; padding: 0; }
    .no-print { display: none !important; }
  }
</style>
</head>
<body>
  <div class="invoice-box">
    <div class="invoice-header">
      <div>
        <h2 style="margin:0;">فاتورة رسمية ضريبية</h2>
        <small style="color:#64748b;">رقم الفاتورة: INV-2026-0042</small>
      </div>
      <div>
        <h3 style="margin:0;">مؤسسة الحلول الرقمية</h3>
      </div>
    </div>
    <!-- تفاصيل الفاتورة والعميل والجدول -->
  </div>
</body>
</html>

الحلول البرمجية الجاهزة من استوديو أنتيجرافيتي (Antigravity Dev Studio)

إذا كنت تبحث عن أنظمة متكاملة جاهزة للعمل الفوري دون الحاجة لكتابة كل سطر من الصفر، يمكنك الحصول على الكود المصدري الكامل مع ترخيص تجاري مدى الحياة عبر متجرنا الرسمي:

🛍️ OrderFlow Pro ($29)

متجر إلكتروني متكامل للطلب عبر واتساب وسلة تسوق ذكية، لوحة تحكم CRM لإدارة حالات الطلبات، تحليل إيرادات آخر 7 أيام، ونظام توليد فواتير رسمية ثنائية اللغة (عربي/إنجليزي) بدون أي مكتبات خارجية.

📄 DocuPulse Pro ($19)

استوديو مخصص لإرسال عروض الأسعار التفاعلية بروابط توقيع رقمية معتمدة للعملاء، توليد الفواتير دفعة واحدة من ملفات الإكسل (Batch CSV)، وإرسال رسائل تذكير تلقائية بالدفعات المتأخرة عبر واتساب.

🎁 حزمة أدوات بايثون للأتمتة (مجاناً $0+)

حزمة مجانية تحتوي على 5 سكربتات جاهزة للتشغيل الفوري: تنظيف وتلخيص ملفات CSV، مراقبة المواقع، تنظيم الملفات، نسخ احتياطي لقواعد البيانات، ومولد فواتير عربي/إنجليزي.

🚀 الحزمة البرمجية الكاملة Full-Stack Pro Bundle ($45 — وفر $17)

تحصل على الأكواد المصدرية الكاملة للأنظمة الثلاثة (OrderFlow Pro و DocuPulse Pro وإضافة كروم TabPilot Pro) بالإضافة إلى حزمة أدوات الأتمتة ودليل إعادة التسمية التجارية للوكالات والمطورين بقيمة $45 فقط (بدلاً من $62).

كود خصم حصري: استخدم كوبون LAUNCH20 في صفحة الدفع للحصول على خصم إضافي 20% لتصبح الحزمة الكاملة بسعر $36 فقط!

🌐 رابط المتجر الرسمي: https://antigone16.gumroad.com/

هل تحتاج إلى نظام مخصص أو أتمتة حصرية لمشروعك؟

يقدّم فريقنا الهندسي خدمات تطوير خاصة للمتاجر والشركات العربية:

بناء منصات مبيعات وتجارة عبر واتساب مخصصة بالكامل.
ربط قواعد البيانات وأتمتة التقارير المالية والإدارية.
إضافات متصفح كروم خاصة لتسريع أعمال فريقك.

تواصل مباشرة مع المهندس المسؤول عبر البريد الإلكتروني:

📩 antig6464@gmail.com (نضمن الرد خلال 24 ساعة).

Self-Hosted WhatsApp E-Commerce & Automated Client Proposals in Pure Python + SQLite (Zero SaaS Fees)

Antigravity Dev Studio — Sun, 01 Nov 2026 17:46:09 +0000

Running an online store or a freelance consulting business in 2026 often feels like a slow bleed of monthly SaaS subscriptions.

You pay $29/month for a basic Shopify tier, another $15/month for a proposal signing app, $20/month for an invoice generator, and another $30/month for automated WhatsApp messaging plugins. Before making your first dollar in profit, your business is saddled with over $1,000 a year in fixed recurring overhead.

Worse, your customer data, order history, and client contracts sit locked inside third-party walled gardens that can hike prices, change terms, or suspend your account at any moment.

Over the past year at Antigravity Dev Studio, we set out to prove a different thesis: You can build a high-performance, self-hosted e-commerce checkout engine and client proposal portal using only the Python standard library and SQLite.

No Django, no Celery, no Redis, and no monthly fees.

In this deep-dive tutorial, we will walk through the exact architecture and runnable code for three mission-critical components:

Generating pre-filled, structured WhatsApp checkout URLs with zero API gateway fees.
Building an atomic, collision-free invoice numbering system on SQLite WAL mode.
Securing client proposal digital acceptance links using cryptographic HMAC signatures.

1. Zero-Fee WhatsApp Checkout URL Builder

In emerging e-commerce markets across Latin America, the Middle East, Africa, and Southeast Asia, WhatsApp is the dominant communication channel. Customers often abandon traditional multi-step checkout funnels that force account creation or require complex payment gateways.

Instead of paying a third-party WhatsApp Business API provider hundreds of dollars in monthly platform fees, you can use the official https://wa.me/ direct URL protocol. When a customer clicks "Place Order via WhatsApp", your Python backend formats their entire shopping cart, customer notes, delivery address, and order code into an encoded message.

When the customer taps the link on mobile or desktop, WhatsApp opens instantly with a perfectly structured, ready-to-send message:

import urllib.parse
from typing import Any, Dict, List

def build_whatsapp_order_url(
    business_phone: str,
    order_code: str,
    customer_name: str,
    customer_phone: str,
    delivery_address: str,
    items: List[Dict[str, Any]],
    subtotal: float,
    discount_amount: float,
    delivery_fee: float,
    total: float,
    currency: str = "USD"
) -> str:
    """
    Constructs an official, encoded WhatsApp Web/App direct checkout URL.
    Works natively on iOS, Android, macOS, and Windows.
    """
    # Clean phone number (strip spaces, dashes, plus signs)
    clean_phone = "".join(ch for ch in business_phone if ch.isdigit())

    # Build clean line items breakdown
    item_lines = []
    for item in items:
        qty = item.get("qty", 1)
        name = item.get("name", "Product")
        price = item.get("price", 0.0)
        item_lines.append(f"• {qty}x {name} — {currency} {price * qty:,.2f}")

    items_block = "\n".join(item_lines)

    # Formatted customer message
    message = (
        f"🛍️ *NEW ORDER: #{order_code}*\n"
        f"━━━━━━━━━━━━━━━━━━\n"
        f"👤 *Customer:* {customer_name.strip()}\n"
        f"📞 *Phone:* {customer_phone.strip()}\n"
        f"📍 *Delivery Address:* {delivery_address.strip()}\n\n"
        f"📦 *Ordered Items:*\n"
        f"{items_block}\n\n"
        f"━━━━━━━━━━━━━━━━━━\n"
        f"💰 *Subtotal:* {currency} {subtotal:,.2f}\n"
    )

    if discount_amount > 0:
        message += f"🏷️ *Discount:* -{currency} {discount_amount:,.2f}\n"

    message += (
        f"🚚 *Delivery Fee:* {currency} {delivery_fee:,.2f}\n"
        f"✅ *TOTAL AMOUNT:* {currency} {total:,.2f}\n"
        f"━━━━━━━━━━━━━━━━━━\n"
        f"Please confirm availability and dispatch details!"
    )

    # Encode message safely for URL transmission
    encoded_text = urllib.parse.quote(message)
    return f"https://wa.me/{clean_phone}?text={encoded_text}"

Testing the Output

sample_items = [
    {"name": "Mechanical Keyboard Pro", "qty": 1, "price": 89.00},
    {"name": "USB-C Braided Cable", "qty": 2, "price": 12.50},
]

url = build_whatsapp_order_url(
    business_phone="+1 (555) 019-2834",
    order_code="ORD-78241",
    customer_name="Alex Mercer",
    customer_phone="+1 555 982 1102",
    delivery_address="742 Evergreen Terrace, Springfield",
    items=sample_items,
    subtotal=114.00,
    discount_amount=10.00,
    delivery_fee=5.00,
    total=109.00
)

print(url)

The resulting link is clean, works without any third-party gateway dependencies, and provides customers with an immediate human connection to your store.

2. Atomic SQLite WAL Invoicing & Sequential Numbering

When building an invoicing engine for clients, sequential and collision-free document numbering (such as INV-2026-001, INV-2026-002) is legally required in most jurisdictions.

If two users or background tasks generate an invoice at the exact same millisecond, a standard SQL query without proper locking will generate duplicate invoice codes or trigger database locked errors.

By leveraging SQLite Write-Ahead Logging (WAL) and an explicit write-transaction loop, you guarantee zero collisions and sub-millisecond execution:

import contextlib
import datetime as dt
import pathlib
import sqlite3
from typing import Generator

class InvoiceDatabase:
    def __init__(self, db_path: pathlib.Path):
        self.db_path = pathlib.Path(db_path)
        self.db_path.parent.mkdir(parents=True, exist_ok=True)
        self._init_schema()

    def _connect(self) -> sqlite3.Connection:
        conn = sqlite3.connect(str(self.db_path), timeout=15.0)
        conn.row_factory = sqlite3.Row
        # WAL mode enables concurrent readers while writing
        conn.execute("PRAGMA journal_mode = WAL;")
        conn.execute("PRAGMA foreign_keys = ON;")
        conn.execute("PRAGMA synchronous = NORMAL;")
        return conn

    @contextlib.contextmanager
    def session(self) -> Generator[sqlite3.Connection, None, None]:
        conn = self._connect()
        try:
            with conn: # Enters transaction: BEGIN IMMEDIATE on writes
                yield conn
        finally:
            conn.close()

    def _init_schema(self) -> None:
        with self.session() as conn:
            conn.executescript("""
                CREATE TABLE IF NOT EXISTS invoices (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    invoice_code TEXT UNIQUE NOT NULL,
                    client_name TEXT NOT NULL,
                    amount REAL NOT NULL CHECK(amount >= 0),
                    status TEXT NOT NULL DEFAULT 'UNPAID',
                    created_at TEXT NOT NULL
                );
                CREATE INDEX IF NOT EXISTS idx_invoices_code ON invoices(invoice_code);
            """)

    def generate_next_invoice(self, client_name: str, amount: float) -> str:
        """
        Atomically queries the current year's highest invoice sequence
        and inserts the next consecutive record in an isolated transaction.
        """
        year = dt.datetime.now(dt.timezone.utc).year
        now_iso = dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat()
        prefix = f"INV-{year}-"

        with self.session() as conn:
            # Find the highest existing sequence for the current year
            row = conn.execute(
                """
                SELECT invoice_code FROM invoices 
                WHERE invoice_code LIKE ? 
                ORDER BY id DESC LIMIT 1
                """,
                (f"{prefix}%",)
            ).fetchone()

            if row:
                last_code = row["invoice_code"]
                try:
                    last_num = int(last_code.split("-")[-1])
                    next_num = last_num + 1
                except ValueError:
                    next_num = 1
            else:
                next_num = 1

            invoice_code = f"{prefix}{next_num:04d}"

            conn.execute(
                """
                INSERT INTO invoices (invoice_code, client_name, amount, status, created_at)
                VALUES (?, ?, ?, 'UNPAID', ?)
                """,
                (invoice_code, client_name.strip(), round(amount, 2), now_iso)
            )

            return invoice_code

Because SQLite serializes writes at the file level inside with conn:, concurrent invoice generations will wait their turn cleanly rather than colliding.

3. Cryptographic Proposal Approvals via HMAC Tokens

When sending proposals or fee quotes to clients, you do not want to force them to create a username and password just to approve a scope of work. At the same time, you cannot use easily guessable sequential URLs (like /proposals/42/accept), as anyone could guess the URL and fake an approval.

Using standard library hmac and hashlib, you can generate tamper-proof signed authorization URLs. When the client clicks "Accept & Sign", your backend verifies that the token was signed with your server's secret key before marking the proposal as legally accepted:

import hashlib
import hmac
import secrets
import time

SERVER_SECRET_KEY = secrets.token_bytes(32) # Store securely in env / config

def generate_proposal_approval_token(proposal_id: str, client_email: str) -> str:
    """
    Generates a cryptographically signed URL token valid for client signature.
    """
    timestamp = str(int(time.time()))
    payload = f"{proposal_id}|{client_email.strip().lower()}|{timestamp}".encode("utf-8")

    # Generate HMAC-SHA256 signature
    sig = hmac.new(SERVER_SECRET_KEY, payload, hashlib.sha256).hexdigest()

    # Token structure: timestamp.signature
    return f"{timestamp}.{sig}"

def verify_proposal_approval_token(proposal_id: str, client_email: str, token: str, max_age_days: int = 30) -> bool:
    """
    Verifies that the proposal token was signed with the server key and has not expired.
    """
    try:
        timestamp_str, candidate_sig = token.split(".", 1)
        created_time = int(timestamp_str)

        # Check expiration
        max_age_seconds = max_age_days * 86400
        if time.time() - created_time > max_age_seconds:
            return False # Token expired

        expected_payload = f"{proposal_id}|{client_email.strip().lower()}|{timestamp_str}".encode("utf-8")
        expected_sig = hmac.new(SERVER_SECRET_KEY, expected_payload, hashlib.sha256).hexdigest()

        # Constant-time comparison prevents timing attacks
        return hmac.compare_digest(candidate_sig, expected_sig)
    except Exception:
        return False

When verified, the system records the client's IP, acceptance timestamp, and digital signature string, instantly locking the proposal into a frozen state.

Production Applications from Antigravity Dev Studio

If you don't want to build these architectures from scratch, we have packaged our complete, battle-tested production systems into modular commercial toolkits:

🛍️ OrderFlow Pro ($29)

The complete WhatsApp e-commerce storefront, interactive shopping cart, 1-click WhatsApp order generator, inventory manager, admin CRM with 7-day revenue analytics, and bilingual print-ready PDF invoices.

Runtime: Pure Python 3.10+ standard library and SQLite WAL.
License: Full unminified commercial source code.

📄 DocuPulse Pro ($19)

The dedicated client proposal portal and automated invoicing studio. Features interactive proposal links with digital signatures, batch CSV-to-invoice processing (generate 100+ invoices from a single spreadsheet in seconds), and 1-click WhatsApp/Email overdue payment follow-ups.

Runtime: Pure Python 3.10+ standard library and SQLite WAL.
License: Full unminified commercial source code.

🎁 Python Automation Starter Kit (FREE / $0+)

Want to inspect our coding patterns for free? Download five complete zero-dependency scripts: CSV cleaner & KPI report, folder organizer, website uptime monitor, SQLite live hot backup, and bilingual invoice renderer.

🚀 Full-Stack Pro Source Bundle ($45 — Save $17)

Get all three commercial tools (OrderFlow Pro, DocuPulse Pro, and TabPilot & WebClipper Pro) plus the Python Starter Kit and the Agency White-Labeling Guide for a single discounted price of $45 (Regular $62).

Special Launch Discount: Enter coupon code LAUNCH20 at checkout on Gumroad for an additional 20% off (Only $36)!

Explore our complete software catalog at our official storefront:
🌐 Antigravity Dev Studio on Gumroad

Have questions or need custom business software engineered for your team? Reach out directly at antig6464@gmail.com.

Manifest V3 Without Bloat: Building a Tab Workspace Manager, Markdown Web Clipper & Service Worker Pomodoro in Pure JS

Antigravity Dev Studio — Sun, 01 Nov 2026 15:29:05 +0000

When Google rolled out Chrome Extensions Manifest V3 (MV3), the web development community let out a collective groan. Persistent background pages were killed off, replaced by transient Background Service Workers that shut down after 30 seconds of inactivity. WebRequest APIs were restricted, and many classic productivity extensions became sluggish or broke entirely.

Many developers reacted by pulling in heavy bundlers—Webpack, Vite, Rollup, and layers of framework dependencies—just to manage a simple popup and sync some state.

When building TabPilot & WebClipper Pro, our goal was the complete opposite:
Build a lightning-fast, production-grade Chrome extension using 100% pure vanilla JavaScript, zero external npm packages, zero bundlers, and an offline-first architecture.

In this breakdown, I will show you how to solve the three hardest architectural challenges in modern Manifest V3 development:

Keeping timers and state alive when the Background Service Worker sleeps (via chrome.alarms).
Extracting clean, structured GitHub-Flavored Markdown directly from live webpage DOMs (without 100KB libraries like Turndown).
Safely deduplicating browser tabs across windows with zero UI lag.

1. Surviving Service Worker Sleep: Alarms Over `setInterval`

In Manifest V2, developers routinely put setInterval() in a persistent background script to run Pomodoro timers, sync background tasks, or poll APIs.

In Manifest V3, this will fail silently. If the user does not interact with your extension, Chrome will terminate the Service Worker thread after 30 seconds to conserve memory and battery. Your setInterval simply vanishes into thin air.

The correct, bulletproof approach is to combine chrome.alarms with chrome.storage.local. When an alarm fires, Chrome wakes the Service Worker up, executes the listener, and allows it to go back to sleep.

Here is the exact focus sprint implementation from TabPilot Pro's background.js:

/**
 * TabPilot Pro - Background Focus Timer (MV3 Service Worker Safe)
 */
const FOCUS_ALARM = "tabpilot_focus_tick";

async function getStorage(keys) {
  return new Promise((resolve) => chrome.storage.local.get(keys, resolve));
}

async function setStorage(obj) {
  return new Promise((resolve) => chrome.storage.local.set(obj, resolve));
}

// Update the extension icon badge with remaining minutes
function updateFocusBadge(focusState) {
  if (!focusState || !focusState.active) {
    chrome.action.setBadgeText({ text: "" });
    return;
  }
  const remMs = Math.max(0, focusState.endsAt - Date.now());
  const remMin = Math.ceil(remMs / 60000);
  chrome.action.setBadgeBackgroundColor({ color: "#f59e0b" }); // Warm amber
  chrome.action.setBadgeText({ text: `${remMin}m` });
}

// Start a persistent 25-minute sprint
async function startFocusSprint(durationMin = 25) {
  const endsAt = Date.now() + durationMin * 60 * 1000;
  const focusState = { active: true, durationMin, endsAt, startedAt: Date.now() };

  await setStorage({ focusState });
  updateFocusBadge(focusState);

  // Chrome alarms wake up the Service Worker every 1 minute
  chrome.alarms.create(FOCUS_ALARM, { periodInMinutes: 1 });
}

// The alarm handler that survives service worker dormancy
chrome.alarms.onAlarm.addListener(async (alarm) => {
  if (alarm.name !== FOCUS_ALARM) return;

  const { focusState, focusStats = { completedSprints: 0, totalMinutes: 0 } } =
    await getStorage(["focusState", "focusStats"]);

  if (!focusState || !focusState.active) {
    chrome.alarms.clear(FOCUS_ALARM);
    chrome.action.setBadgeText({ text: "" });
    return;
  }

  // Timer complete
  if (Date.now() >= focusState.endsAt) {
    const nextStats = {
      completedSprints: (focusStats.completedSprints || 0) + 1,
      totalMinutes: (focusStats.totalMinutes || 0) + (focusState.durationMin || 25)
    };

    await setStorage({
      focusState: { ...focusState, active: false, completedAt: new Date().toISOString() },
      focusStats: nextStats
    });

    chrome.alarms.clear(FOCUS_ALARM);

    // Flash green completion badge for 6 seconds
    chrome.action.setBadgeBackgroundColor({ color: "#10b981" });
    chrome.action.setBadgeText({ text: "DONE" });
    setTimeout(() => chrome.action.setBadgeText({ text: "" }), 6000);
  } else {
    updateFocusBadge(focusState);
  }
});

Because the state is persisted in chrome.storage.local and synchronized on every alarm tick, the timer remains 100% accurate even if Chrome aggressively pauses the service worker.

2. Zero-Dependency DOM-to-Markdown Extraction

Most web clippers package large npm libraries (like turndown or readability) that inflate extension size and introduce security vulnerabilities.

In TabPilot Pro, we wrote a lightweight, pure JavaScript content script (content_clipper.js) that injects into any webpage via chrome.scripting.executeScript, parses article content, handles nested elements, and outputs GitHub-Flavored Markdown.

Clean HTML Table to Markdown Converter

Tables are notoriously tricky to convert from DOM nodes without external tools. Here is how we convert arbitrary HTML <table> elements into aligned Markdown tables:

function convertTable(tableEl) {
  const rows = Array.from(tableEl.querySelectorAll("tr"));
  if (!rows.length) return "";

  // Extract cell text and escape literal pipes
  const matrix = rows.map((tr) =>
    Array.from(tr.querySelectorAll("th, td")).map((cell) =>
      (cell.innerText || cell.textContent || "")
        .replace(/\s+/g, " ")
        .trim()
        .replace(/\|/g, "\\|")
    )
  ).filter((r) => r.length > 0);

  if (!matrix.length) return "";

  // Normalize column counts across varying row lengths
  const colCount = Math.max(...matrix.map((r) => r.length));
  const pad = (row) => {
    const copy = row.slice();
    while (copy.length < colCount) copy.push("");
    return copy;
  };

  const header = pad(matrix[0]);
  const sep = header.map(() => "---");
  const body = matrix.slice(1).map(pad);

  const lines = [
    `| ${header.join(" | ")} |`,
    `| ${sep.join(" | ")} |`,
    ...body.map((r) => `| ${r.join(" | ")} |`)
  ];

  return `\n\n${lines.join("\n")}\n\n`;
}

Recursive Node Traversal with Syntax Blocks

For code blocks, headings, blockquotes, and lists, a simple recursive walker ignores noisy tags (scripts, styles, iframes, navigation) and preserves syntax highlighting tags:

const SKIP_TAGS = new Set([
  "SCRIPT", "STYLE", "NOSCRIPT", "IFRAME", "SVG", "CANVAS",
  "NAV", "FOOTER", "ASIDE", "FORM", "BUTTON", "INPUT", "SELECT"
]);

function nodeToMarkdown(node) {
  if (!node) return "";
  if (node.nodeType === Node.TEXT_NODE) {
    return node.nodeValue.replace(/\s+/g, " ");
  }
  if (node.nodeType !== Node.ELEMENT_NODE) return "";

  const tag = node.tagName.toUpperCase();
  if (SKIP_TAGS.has(tag) || node.getAttribute("aria-hidden") === "true") return "";

  if (tag === "BR") return "\n";
  if (tag === "HR") return "\n\n---\n\n";
  if (tag === "TABLE") return convertTable(node);

  // Preserve preformatted code blocks with programming language
  if (tag === "PRE") {
    const codeEl = node.querySelector("code");
    const cls = (codeEl && codeEl.className) || node.className || "";
    const langMatch = cls.match(/language-([a-zA-Z0-9_+-]+)/);
    const lang = langMatch ? langMatch[1] : "";
    const rawCode = (codeEl || node).textContent || "";
    return `\n\n\`\`\`${lang}\n${rawCode.replace(/\n+$/, "")}\n\`\`\`\n\n`;
  }

  // Headings
  if (/^H[1-6]$/.test(tag)) {
    const level = Number(tag[1]);
    const text = Array.from(node.childNodes).map(nodeToMarkdown).join("").trim();
    return text ? `\n\n${"#".repeat(level)} ${text}\n\n` : "";
  }

  // Links
  if (tag === "A") {
    const href = node.getAttribute("href");
    const linkText = Array.from(node.childNodes).map(nodeToMarkdown).join("").trim();
    if (!href || !linkText) return linkText;
    const absUrl = new URL(href, document.baseURI).href;
    return `[${linkText}](${absUrl})`;
  }

  // Recurse child nodes for containers
  return Array.from(node.childNodes).map(nodeToMarkdown).join("");
}

This tiny, 150-line extractor handles selection clips or full-page articles cleanly and runs in under 4ms on modern websites.

3. Intelligent Tab Workspace Saving & URL Deduplication

Developers and researchers easily accumulate 50+ open tabs across multiple windows. TabPilot Pro groups tabs into named workspaces (Engineering, Research, Design) and provides a 1-click Deduplicate Tabs function.

To properly deduplicate tabs, you cannot simply compare exact URL strings—anchor links (#section-2) and trailing slashes will fool a naive check:

async function deduplicateTabs() {
  const tabs = await chrome.tabs.query({ currentWindow: true });
  const seenUrls = new Set();
  const duplicateIds = [];

  for (const tab of tabs) {
    // Strip URL fragments and trailing slashes for clean matching
    const normalized = (tab.url || "").split("#")[0].replace(/\/$/, "");
    if (!normalized || normalized.startsWith("chrome://")) continue;

    if (seenUrls.has(normalized)) {
      duplicateIds.push(tab.id);
    } else {
      seenUrls.add(normalized);
    }
  }

  if (duplicateIds.length > 0) {
    await chrome.tabs.remove(duplicateIds);
    // Flash badge showing how many tabs were purged
    chrome.action.setBadgeBackgroundColor({ color: "#10b981" });
    chrome.action.setBadgeText({ text: `-${duplicateIds.length}` });
    setTimeout(() => chrome.action.setBadgeText({ text: "" }), 2400);
  }

  return { removedCount: duplicateIds.length };
}

To bind this to a global keyboard shortcut, we declare commands in manifest.json:

{
  "commands": {
    "quick_clip_page": {
      "suggested_key": {
        "default": "Alt+Shift+M"
      },
      "description": "Clip active webpage or selection to clean Markdown"
    }
  }
}

Whenever the user hits Alt+Shift+M, the background service worker extracts the page content, persists it to local storage, and flashes a confirmation badge on the toolbar icon.

Get the Full Source & Commercial License

If you want the complete, unbundled source code of TabPilot Pro—including the full Glassmorphism dark/light popup interface, fuzzy search, workspace backup/restore, and CSV export:

🚀 TabPilot & WebClipper Pro ($14 on Gumroad)

What's included: 100% clean, unminified source code (manifest.json, background.js, content_clipper.js, popup.html/css/js), high-res store icons, and a full commercial license to customize, rebrand, or publish to the Chrome Web Store.
Zero build steps: Load it directly into chrome://extensions via "Load unpacked" and start developing immediately.

Looking for zero-dependency Python backend automation too?
Check out our free starter toolkit:
🎁 Download the Free Python Automation Starter Kit ($0+)

Visit our studio storefront for more production-ready engineering blueprints:
🌐 Antigravity Dev Studio Gumroad Storefront

Building Zero-Dependency Python + SQLite Business Apps (Plus 5 Free Scripts)

Antigravity Dev Studio — Sun, 01 Nov 2026 15:26:57 +0000

Modern software development often pushes us toward massive dependency trees. You start a simple internal invoice generator or an e-commerce order manager, and before you know it, you have a 350MB node_modules folder, a fragile Python virtual environment with 42 transient packages, or a multi-container Docker compose file just to render an HTML invoice and save a row to a database.

Two years down the road, you clone the repository on a client machine or a new server, run pip install -r requirements.txt, and watch it explode because a C-extension failed to compile or an API changed.

Over the past year, I shifted my architecture for internal tools, freelance client deliverables, and micro-business software to a strict Zero-Dependency Standard Library philosophy in Python 3.10+.

The result? Single-folder applications that start in under 40 milliseconds, consume less than 28MB of RAM, run identically on Windows, macOS, and Linux without installing a single external package, and can run uninterrupted for five years without breaking.

In this guide, I will break down three architectural patterns you can immediately steal for your own tools, followed by five production-ready scripts you can download for free today.

1. SQLite WAL Mode & Collision-Free Atomic Numbering

SQLite is embedded into Python's standard library (sqlite3). When properly configured, it can easily handle hundreds of concurrent requests, transactions, and millions of records with zero administrative overhead.

By default, SQLite uses rollback journals which lock the entire database during writes. By switching to Write-Ahead Logging (WAL) and enforcing foreign keys upon connection, readers never block writers, and writers never block readers.

Here is the exact thread-safe session pattern used in our production applications:

import contextlib
import pathlib
import secrets
import sqlite3
from typing import Generator

class BusinessDatabase:
    def __init__(self, db_path: pathlib.Path):
        self.db_path = pathlib.Path(db_path)
        self.db_path.parent.mkdir(parents=True, exist_ok=True)
        self._init_schema()

    def _connect(self) -> sqlite3.Connection:
        conn = sqlite3.connect(str(self.db_path), timeout=15.0)
        conn.row_factory = sqlite3.Row
        # WAL mode allows concurrent readers alongside a writer
        conn.execute("PRAGMA journal_mode = WAL;")
        conn.execute("PRAGMA foreign_keys = ON;")
        conn.execute("PRAGMA synchronous = NORMAL;")
        return conn

    @contextlib.contextmanager
    def session(self) -> Generator[sqlite3.Connection, None, None]:
        conn = self._connect()
        try:
            with conn:  # Automatically enters transaction (BEGIN/COMMIT/ROLLBACK)
                yield conn
        finally:
            conn.close()

    def _init_schema(self) -> None:
        with self.session() as conn:
            conn.executescript("""
                CREATE TABLE IF NOT EXISTS orders (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    order_code TEXT UNIQUE NOT NULL,
                    customer_name TEXT NOT NULL,
                    customer_phone TEXT NOT NULL,
                    total REAL NOT NULL CHECK(total >= 0),
                    status TEXT NOT NULL DEFAULT 'new',
                    created_at TEXT NOT NULL
                );
                CREATE INDEX IF NOT EXISTS idx_orders_code ON orders(order_code);
            """)

Generating Human-Friendly Atomic Order Codes

Auto-incrementing database integers (1, 2, 3) leak your business volume to customers and competitors. However, long random UUIDs (e7f12e84-...) are frustrating for customers typing order IDs into WhatsApp or bank transfer notes.

Instead, we use a collision-safe formatted token inside our write transaction:

import datetime as dt

def create_order(db: BusinessDatabase, customer_name: str, customer_phone: str, total: float) -> str:
    with db.session() as conn:
        now = dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat()

        # Format: ORD-XXXXX (cryptographically random 5-digit number)
        order_code = f"ORD-{secrets.randbelow(90000) + 10000}"
        while conn.execute("SELECT 1 FROM orders WHERE order_code = ?", (order_code,)).fetchone():
            order_code = f"ORD-{secrets.randbelow(90000) + 10000}"

        conn.execute(
            """
            INSERT INTO orders (order_code, customer_name, customer_phone, total, created_at)
            VALUES (?, ?, ?, ?, ?)
            """,
            (order_code, customer_name.strip(), customer_phone.strip(), round(total, 2), now)
        )
        return order_code

2. A Zero-Dependency JSON API & Static Server via `http.server`

You don't need FastAPI, Flask, or Uvicorn to serve a rich modern Single Page Application (SPA) or a RESTful administrative dashboard. Python ships with http.server.ThreadingHTTPServer.

Here is a hardened server that serves JSON endpoints, reads request payloads, and securely serves static HTML/CSS/JS files without directory traversal vulnerabilities:

import json
import os
import pathlib
import urllib.parse
from http import HTTPStatus
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

ROOT_DIR = pathlib.Path(__file__).resolve().parent
STATIC_DIR = ROOT_DIR / "static"

class ModernAppHandler(BaseHTTPRequestHandler):
    def _send_json(self, payload: dict | list, status: HTTPStatus = HTTPStatus.OK):
        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Access-Control-Allow-Origin", "*")
        self.end_headers()
        self.wfile.write(body)

    def _read_json(self) -> dict:
        length = int(self.headers.get("Content-Length") or 0)
        if length <= 0:
            return {}
        raw = self.rfile.read(length).decode("utf-8")
        return json.loads(raw)

    def do_GET(self):
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path

        # JSON API Route
        if path == "/api/health":
            return self._send_json({"status": "healthy", "service": "order-engine"})

        # Static Asset Serving with Path Traversal Protection
        if path == "/":
            path = "/index.html"

        target_file = (STATIC_DIR / path.lstrip("/")).resolve()

        # Verify the file is strictly inside the designated static folder
        if not str(target_file).startswith(str(STATIC_DIR.resolve())) or not target_file.is_file():
            self.send_response(HTTPStatus.NOT_FOUND)
            self.end_headers()
            self.wfile.write(b"404 Not Found")
            return

        content_types = {
            ".html": "text/html; charset=utf-8",
            ".css": "text/css; charset=utf-8",
            ".js": "application/javascript; charset=utf-8",
            ".png": "image/png",
            ".svg": "image/svg+xml",
        }
        mime = content_types.get(target_file.suffix.lower(), "application/octet-stream")
        data = target_file.read_bytes()

        self.send_response(HTTPStatus.OK)
        self.send_header("Content-Type", mime)
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

def run_server(port: int = 8080):
    server = ThreadingHTTPServer(("127.0.0.1", port), ModernAppHandler)
    print(f"[*] Zero-dependency server active on http://127.0.0.1:{port}")
    server.serve_forever()

3. Bilingual (LTR English & RTL Arabic) Print-to-PDF Invoicing

One of the biggest pain points in small business billing is generating PDF invoices. Heavy PDF generation binaries (weasyprint, wkhtmltopdf, reportlab) often suffer from messy Arabic font shaping, broken bidirectional text, or painful OS-level library dependencies.

The cleanest, most durable solution is pure HTML5 + CSS @media print. Every modern desktop browser (Chrome, Edge, Safari, Firefox) includes a world-class rendering engine that outputs vector-crisp PDFs via window.print() or headless mode.

By dynamically applying dir="rtl" or dir="ltr" and using standard typographic styles, you can support English and Arabic seamlessly:

import html
import pathlib

def render_bilingual_invoice(data: dict, output_file: pathlib.Path) -> pathlib.Path:
    lang = data.get("lang", "en").lower()
    is_ar = lang == "ar"
    direction = "rtl" if is_ar else "ltr"
    currency = data.get("currency", "USD")

    # Context-aware labels
    labels = {
        "title": "فاتورة رسمية / OFFICIAL INVOICE" if is_ar else "OFFICIAL INVOICE",
        "billed_to": "العميل / Billed To" if is_ar else "Billed To",
        "desc": "الوصف / Description" if is_ar else "Description",
        "qty": "الكمية / Qty" if is_ar else "Qty",
        "unit_price": "السعر / Price" if is_ar else "Unit Price",
        "line_total": "الإجمالي / Total" if is_ar else "Total",
        "grand_total": "المبلغ المستحق / Amount Due" if is_ar else "Amount Due",
    }

    items = data.get("items", [])
    subtotal = sum(float(i["qty"]) * float(i["price"]) for i in items)
    tax_rate = float(data.get("tax_rate", 0.0))
    tax = subtotal * (tax_rate / 100.0)
    total = subtotal + tax

    rows_html = "".join(
        f"""<tr>
            <td>{html.escape(i['name'])}</td>
            <td style="text-align: center;">{float(i['qty']):g}</td>
            <td style="text-align: end;">{currency} {float(i['price']):,.2f}</td>
            <td style="text-align: end; font-weight: 700;">{currency} {(float(i['qty']) * float(i['price'])):,.2f}</td>
        </tr>"""
        for i in items
    )

    template = f"""<!DOCTYPE html>
<html lang="{lang}" dir="{direction}">
<head>
<meta charset="UTF-8">
<title>Invoice {html.escape(data.get('code', 'INV-001'))}</title>
<style>
    @page {{ size: A4; margin: 15mm; }}
    body {{
        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Tahoma, sans-serif;
        background: #f8fafc;
        color: #0f172a;
        margin: 0;
        padding: 32px;
    }}
    .invoice-card {{
        max-width: 800px;
        margin: 0 auto;
        background: #ffffff;
        padding: 48px;
        border-radius: 12px;
        box-shadow: 0 4px 20px rgba(0,0,0,0.05);
    }}
    .header {{
        display: flex;
        justify-content: space-between;
        align-items: center;
        border-bottom: 2px solid #0f172a;
        padding-bottom: 24px;
        margin-bottom: 32px;
    }}
    table {{ width: 100%; border-collapse: collapse; margin: 28px 0; }}
    th, td {{ padding: 14px 12px; border-bottom: 1px solid #e2e8f0; }}
    th {{ background: #f1f5f9; font-size: 13px; text-transform: uppercase; color: #475569; }}
    .grand-total {{
        display: flex;
        justify-content: flex-end;
        align-items: center;
        gap: 16px;
        font-size: 24px;
        font-weight: 900;
        color: #059669;
        margin-top: 24px;
    }}
    @media print {{
        body {{ background: transparent; padding: 0; }}
        .invoice-card {{ box-shadow: none; border-radius: 0; padding: 0; }}
        .no-print {{ display: none !important; }}
    }}
</style>
</head>
<body>
    <div class="invoice-card">
        <div class="header">
            <div>
                <h1 style="margin: 0; font-size: 26px;">{html.escape(data.get('company_name', 'Studio'))}</h1>
                <p style="margin: 4px 0 0; color: #64748b; font-size: 14px;">{labels['title']}</p>
            </div>
            <div style="text-align: end;">
                <div style="font-size: 20px; font-weight: 800;">{html.escape(data.get('code', 'INV-001'))}</div>
                <div style="color: #64748b; font-size: 14px;">{html.escape(data.get('date', ''))}</div>
            </div>
        </div>
        <div style="margin-bottom: 24px;">
            <div style="font-size: 12px; text-transform: uppercase; color: #64748b; font-weight: 700;">{labels['billed_to']}</div>
            <div style="font-size: 18px; font-weight: 700; margin-top: 4px;">{html.escape(data.get('client_name', ''))}</div>
        </div>
        <table>
            <thead>
                <tr>
                    <th style="text-align: start;">{labels['desc']}</th>
                    <th>{labels['qty']}</th>
                    <th style="text-align: end;">{labels['unit_price']}</th>
                    <th style="text-align: end;">{labels['line_total']}</th>
                </tr>
            </thead>
            <tbody>
                {rows_html}
            </tbody>
        </table>
        <div class="grand-total">
            <span>{labels['grand_total']}:</span>
            <span>{currency} {total:,.2f}</span>
        </div>
    </div>
</body>
</html>"""
    output_file.write_text(template, encoding="utf-8")
    return output_file

4. Take the Free Starter Kit: 5 Zero-Dependency Business Scripts

To help developers and solo operators launch these patterns without reinventing the wheel, we compiled five complete, production-tested scripts into our Python Automation Starter Kit.

All five scripts are 100% free ($0+), require zero pip install, and run out of the box on Windows, macOS, and Linux:

01_csv_cleaner_and_kpi_report.py: Reads messy raw e-commerce CSV dumps, automatically detects phone/email column formats, cleans currency strings, eliminates duplicates, and generates a formatted Markdown KPI summary with total revenue, average order value, and top SKUs.
02_smart_folder_organizer.py: Organizes chaotic Downloads or desktop folders by MIME type and extension into categorised subfolders (Documents, Spreadsheets, Archives, Media), with a live rollback log to undo moves safely.
03_website_uptime_and_keyword_monitor.py: Monitors a fleet of client websites or checkout endpoints using standard urllib.request. Verifies HTTP response codes, latency in milliseconds, and the presence of critical HTML keywords (e.g. "Add to Cart" or "Checkout"), outputting structured JSON logs.
04_sqlite_backup_and_json_exporter.py: Performs zero-downtime hot backups of live SQLite databases using SQLite's native backup API (sqlite3.Connection.backup), verifies database page integrity (PRAGMA integrity_check), and exports table snapshots to clean JSON.
05_bilingual_invoice_generator.py: Standalone implementation of the bilingual RTL/LTR invoice generator shown above, reading line items from JSON or CLI flags and creating print-ready HTML/PDF documents.

You can download the full starter bundle right here:
👉 Download the Free Python Automation Starter Kit ($0+)

5. Full Production Solutions from Our Studio

When your business operations grow beyond single scripts and you need full-fledged user portals, multi-tenant databases, WhatsApp order flows, and automated proposal pipelines, we build modular, turnkey software engines with the same zero-dependency purity:

🛍️ OrderFlow Pro — WhatsApp E-Commerce, Invoice & Admin CRM Kit ($29)

What it does: A complete self-hosted e-commerce storefront with an interactive shopping cart, promo code engine, 1-click WhatsApp order checkout (pre-filling order details and addresses into a direct chat message), and a full password-protected administrative CRM.
Tech Highlights: Pure Python standard library, SQLite WAL mode, real-time 7-day revenue telemetry, CSV export, and print-ready bilingual invoices.
Get the source: OrderFlow Pro on Gumroad ($29)

📄 DocuPulse Pro — Client Proposal, Batch CSV Invoice & Follow-Up Studio ($19)

What it does: A dedicated freelance and agency studio that turns messy client agreements into interactive online proposals with digital client acceptance signatures, generates hundreds of client invoices in seconds from batch CSV uploads, and automates overdue payment follow-up reminders.
Tech Highlights: Zero third-party dependencies, built-in SQLite engine, bilingual RTL Arabic and LTR English templates, and instant print-to-PDF invoices.
Get the source: DocuPulse Pro on Gumroad ($19)

Summary & Full Studio Storefront

Choosing a zero-dependency architecture is not about avoiding modern tools—it is about choosing stability, speed, and absolute ownership over your software stack. When you build on Python's built-in standard library and SQLite, your tools run reliably year after year with zero maintenance overhead.

Explore all our commercial toolkits, browser extensions, and automation blueprints at our official storefront:
🌐 Antigravity Dev Studio Gumroad Storefront

Have questions or building your own zero-dependency tools? Drop your feedback or patterns in the comments below!

DEV Community: Antigravity Dev Studio

كيف تبني متجر واتساب إلكتروني ونظام عروض أسعار وفواتير متكامل بلغة بايثون بدون اشتراكات شهرية

1. نموذج العمل: لماذا واتساب + بايثون النقي؟

2. إدارة الفواتير وعروض الأسعار في بايثون: نمط SQLite WAL

3. طباعة الفواتير باللغة العربية (RTL) إلى PDF بجودة متجهة فائقة

الحلول البرمجية الجاهزة من استوديو أنتيجرافيتي (Antigravity Dev Studio)

🛍️ OrderFlow Pro ($29)

📄 DocuPulse Pro ($19)

🎁 حزمة أدوات بايثون للأتمتة (مجاناً $0+)

🚀 الحزمة البرمجية الكاملة Full-Stack Pro Bundle ($45 — وفر $17)

هل تحتاج إلى نظام مخصص أو أتمتة حصرية لمشروعك؟

Self-Hosted WhatsApp E-Commerce & Automated Client Proposals in Pure Python + SQLite (Zero SaaS Fees)

1. Zero-Fee WhatsApp Checkout URL Builder

Testing the Output

2. Atomic SQLite WAL Invoicing & Sequential Numbering

3. Cryptographic Proposal Approvals via HMAC Tokens

Production Applications from Antigravity Dev Studio

🛍️ OrderFlow Pro ($29)

📄 DocuPulse Pro ($19)

🎁 Python Automation Starter Kit (FREE / $0+)

🚀 Full-Stack Pro Source Bundle ($45 — Save $17)

Manifest V3 Without Bloat: Building a Tab Workspace Manager, Markdown Web Clipper & Service Worker Pomodoro in Pure JS

1. Surviving Service Worker Sleep: Alarms Over setInterval

2. Zero-Dependency DOM-to-Markdown Extraction

Clean HTML Table to Markdown Converter

Recursive Node Traversal with Syntax Blocks

3. Intelligent Tab Workspace Saving & URL Deduplication

Get the Full Source & Commercial License

Building Zero-Dependency Python + SQLite Business Apps (Plus 5 Free Scripts)

1. SQLite WAL Mode & Collision-Free Atomic Numbering

Generating Human-Friendly Atomic Order Codes

2. A Zero-Dependency JSON API & Static Server via http.server

3. Bilingual (LTR English & RTL Arabic) Print-to-PDF Invoicing

4. Take the Free Starter Kit: 5 Zero-Dependency Business Scripts

5. Full Production Solutions from Our Studio

🛍️ OrderFlow Pro — WhatsApp E-Commerce, Invoice & Admin CRM Kit ($29)

📄 DocuPulse Pro — Client Proposal, Batch CSV Invoice & Follow-Up Studio ($19)

Summary & Full Studio Storefront

1. Surviving Service Worker Sleep: Alarms Over `setInterval`

2. A Zero-Dependency JSON API & Static Server via `http.server`