TL;DR: This guide walks through building a production-ready Shopify app backend with Laravel — covering OAuth via App Bridge, webhook handling with queues, multi-tenant data isolation, and deployment tips. If you're a Laravel developer building your first Shopify app, this is the architecture guide I wish I had.

Why Laravel for Shopify Apps?

Laravel and Shopify are a surprisingly good pairing. Shopify's REST/GraphQL APIs play well with Laravel's HTTP client, the queue system handles webhooks beautifully, and Eloquent makes multi-tenant data isolation straightforward. Plus, if you're already a Laravel developer, you get to ship faster than learning a new framework.

Let's break this down into the four pillars you need to nail.

1. OAuth Flow with Shopify App Bridge

Shopify apps use OAuth 2.0 for installation. When a merchant clicks "Add app" from the Shopify App Store, Shopify redirects them to your app with a code parameter. Your job is to exchange that code for a permanent access token.

The Installation Flow

Here's what happens step by step:

1. Merchant installs your app from Shopify
2. Shopify redirects to your app with shop, hmac, code, and timestamp
3. You verify the HMAC, exchange the code for an access token
4. Store the token and shop domain — you'll need both forever

Setting Up the OAuth Controller

// routes/web.php
Route::get('/auth', [ShopifyAuthController::class, 'install']);
Route::get('/auth/callback', [ShopifyAuthController::class, 'callback']);

// app/Http/Controllers/ShopifyAuthController.php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;
use App\Models\Shop;

class ShopifyAuthController extends Controller
{
    public function install(Request $request)
    {
        $shop = $request->query('shop');
        $scopes = 'read_products,write_products,read_orders';
        $redirectUri = config('app.url') . '/auth/callback';
        $nonce = bin2hex(random_bytes(16));

        session(['oauth_nonce' => $nonce]);

        $installUrl = "https://{$shop}/admin/oauth/authorize?" . http_build_query([
            'client_id' => config('services.shopify.api_key'),
            'scope' => $scopes,
            'redirect_uri' => $redirectUri,
            'state' => $nonce,
        ]);

        return redirect($installUrl);
    }

    public function callback(Request $request)
    {
        // Verify HMAC first — never skip this
        $hmac = $request->query('hmac');
        $params = $request->except('hmac');
        ksort($params);

        $computedHmac = hash_hmac(
            'sha256',
            http_build_query($params),
            config('services.shopify.api_secret')
        );

        if (!hash_equals($hmac, $computedHmac)) {
            abort(403, 'Invalid HMAC');
        }

        // Exchange code for access token
        $response = Http::post("https://{$request->shop}/admin/oauth/access_token", [
            'client_id' => config('services.shopify.api_key'),
            'client_secret' => config('services.shopify.api_secret'),
            'code' => $request->code,
        ]);

        $accessToken = $response->json('access_token');

        Shop::updateOrCreate(
            ['domain' => $request->shop],
            ['access_token' => $accessToken, 'installed_at' => now()]
        );

        return redirect("https://{$request->shop}/admin/apps/" . config('services.shopify.api_key'));
    }
}

App Bridge Integration

For embedded apps, Shopify uses App Bridge to render your app inside the Shopify admin. On the frontend, you'll need:

// resources/js/app.js
import { createApp } from '@shopify/app-bridge';
import { Redirect } from '@shopify/app-bridge/actions';

const app = createApp({
    apiKey: process.env.SHOPIFY_API_KEY,
    shopOrigin: new URL(window.location).searchParams.get('shop'),
    host: new URL(window.location).searchParams.get('host'),
});

The key insight: always verify HMAC server-side. Never trust client-side data.

2. Webhooks with Laravel Queues and Retries

Shopify sends webhooks for events like order creation, product updates, and app uninstallation. You need to handle these reliably — missing an order webhook means unhappy merchants.

Registering Webhooks

// After OAuth, register your webhooks
Http::withHeaders(['X-Shopify-Access-Token' => $shop->access_token])
    ->post("https://{$shop->domain}/admin/api/2024-01/webhooks.json", [
        'webhook' => [
            'topic' => 'orders/create',
            'address' => config('app.url') . '/api/webhooks/orders',
            'format' => 'json',
        ],
    ]);

The Webhook Controller

// app/Http/Controllers/WebhookController.php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Jobs\ProcessShopifyOrder;
use App\Jobs\HandleAppUninstall;

class WebhookController extends Controller
{
    public function handleOrders(Request $request)
    {
        $this->verifyWebhook($request);

        $shop = Shop::where('domain', $request->header('x-shopify-shop-domain'))
            ->firstOrFail();

        ProcessShopifyOrder::dispatch($shop, $request->all());

        return response()->json(['status' => 'queued'], 200);
    }

    public function handleUninstall(Request $request)
    {
        $this->verifyWebhook($request);

        $shop = Shop::where('domain', $request->header('x-shopify-shop-domain'))
            ->firstOrFail();

        HandleAppUninstall::dispatch($shop);

        return response()->json(['status' => 'ok'], 200);
    }

    private function verifyWebhook(Request $request): void
    {
        $hmac = $request->header('x-shopify-hmac-sha256');
        $computed = base64_encode(
            hash_hmac('sha256', $request->getContent(), config('services.shopify.api_secret'), true)
        );

        if (!hash_equals($hmac, $computed)) {
            abort(401, 'Webhook verification failed');
        }
    }
}

The Queue Job with Retries

// app/Jobs/ProcessShopifyOrder.php
namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Throwable;

class ProcessShopifyOrder implements ShouldQueue
{
    use InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 5;
    public int $backoff = 60; // seconds between retries
    public bool $failOnTimeout = true;

    public function __construct(
        public Shop $shop,
        public array $orderData
    ) {}

    public function handle(): void
    {
        // Your order processing logic here
        // Sync to your database, trigger emails, update inventory, etc.
    }

    public function failed(Throwable $exception): void
    {
        logger()->error('Order webhook failed after 5 retries', [
            'shop' => $this->shop->domain,
            'order_id' => $this->orderData['id'] ?? null,
            'error' => $exception->getMessage(),
        ]);
    }
}

Pro tip: Always return a 200 response immediately and let queues handle the work. Shopify retries webhooks if it doesn't get a 200 within 5 seconds.

3. Multi-Tenant Data Isolation

Every Shopify merchant is a separate tenant. You need to ensure Merchant A never sees Merchant B's data. There are two main approaches:

Approach A: Global Scope (Recommended for Most Apps)

// app/Models/Traits/BelongsToShop.php
namespace App\Models\Traits;

use Illuminate\Database\Eloquent\Builder;

trait BelongsToShop
{
    protected static function bootBelongsToShop(): void
    {
        static::addGlobalScope('shop', function (Builder $builder) {
            if ($shopId = request()->attributes->get('shop_id')) {
                $builder->where('shop_id', $shopId);
            }
        });

        static::creating(function ($model) {
            if ($shopId = request()->attributes->get('shop_id')) {
                $model->shop_id = $shopId;
            }
        });
    }
}

// Middleware that resolves the shop from session/token
namespace App\Http\Middleware;

use Closure;
use App\Models\Shop;

class ResolveShop
{
    public function handle($request, Closure $next)
    {
        $shopDomain = $request->header('x-shopify-shop-domain')
            ?? session('shop_domain');

        $shop = Shop::where('domain', $shopDomain)->firstOrFail();
        $request->attributes->set('shop_id', $shop->id);
        $request->attributes->set('shop', $shop);

        return $next($request);
    }
}

Apply the trait to any model that belongs to a shop:

// app/Models/Product.php
class Product extends Model
{
    use BelongsToShop;
}

Approach B: Separate Databases (For Enterprise Scale)

If you're dealing with heavy per-shop data isolation requirements, use separate databases:

// config/database.php
'shop_connection' => [
    'driver' => 'mysql',
    'database' => env('SHOP_DB_PREFIX', 'shop_') . $shopId,
    // ...
],

This adds complexity (migrations across N databases) but gives you true isolation. For 95% of Shopify apps, the global scope approach is sufficient.

4. Deployment Tips

Environment Essentials

SHOPIFY_API_KEY=your_key
SHOPIFY_API_SECRET=your_secret
SHOPIFY_SCOPES=read_products,write_products,read_orders
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis

Queue Workers

Run queue workers with Supervisor:

# /etc/supervisor/conf.d/shopify-worker.conf
[program:shopify-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /path/to/artisan queue:work redis --sleep=3 --tries=5 --max-time=3600
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
numprocs=3
redirect_stderr=true
stdout_logfile=/var/log/shopify-worker.log

Shopify-Specific Deployment Notes

• HTTPS is mandatory. Shopify won't send webhooks to HTTP endpoints.
• Set your app URL in Shopify Partners dashboard to match your production URL exactly.
• Use Laravel Horizon if you want a dashboard for monitoring webhook processing.
• Rate limits matter. Shopify's REST API allows 2 requests per second per shop. Use Laravel's RateLimiter or throttle your API calls.
• Always handle the app/uninstalled webhook to revoke tokens and clean up data.

Wrapping Up

Building a Shopify app with Laravel comes down to four things:

1. OAuth — verify HMAC, exchange codes, store tokens
2. Webhooks — verify, queue, retry, log failures
3. Multi-tenancy — global scopes or separate databases
4. Reliability — queues, supervisors, monitoring

The architecture is straightforward. The details are where the pain lives — HMAC verification edge cases, webhook retry storms, and Shopify API rate limits. Handle those well and you'll have an app that merchants can trust.

If you're building your first Shopify app, start with the OAuth flow. Get that working, and everything else builds on top of it.

TL;DR: Learn how to integrate OpenAI into your Shopify Laravel app to auto-generate product descriptions, build a Polaris-based admin UI, handle bulk generation with queues, and implement usage-based billing. Everything you need to ship an AI-powered Shopify app feature.

The Opportunity

Writing product descriptions is tedious. Merchants with hundreds of SKUs often have terrible descriptions — or none at all. An AI-powered description generator is one of the highest-value features you can add to a Shopify app, and merchants are willing to pay for it.

Here's how to build it end to end.

1. OpenAI Integration in Laravel

Start by installing the OpenAI PHP client:

composer require openai-php/laravel

Publish the config and add your API key:

OPENAI_API_KEY=sk-...
OPENAI_MODEL=gpt-4o-mini

The Description Generator Service

Create a clean service class that handles prompt engineering and API calls:

// app/Services/DescriptionGenerator.php
namespace App\Services;

use OpenAI\Laravel\Facades\OpenAI;
use App\Models\Shop;

class DescriptionGenerator
{
    public function generate(Shop $shop, array $product, string $tone = 'professional'): string
    {
        $prompt = $this->buildPrompt($product, $tone);

        $response = OpenAI::chat()->create([
            'model' => config('openai.model', 'gpt-4o-mini'),
            'messages' => [
                ['role' => 'system', 'content' => $this->systemPrompt()],
                ['role' => 'user', 'content' => $prompt],
            ],
            'max_tokens' => 500,
            'temperature' => 0.7,
        ]);

        return $response->choices[0]->message->content;
    }

    private function systemPrompt(): string
    {
        return "You are an expert e-commerce copywriter. Write compelling, SEO-friendly "
             . "product descriptions. Use appropriate HTML formatting (h3, p, ul, li). "
             . "Never mention you are an AI. Focus on benefits, not just features.";
    }

    private function buildPrompt(array $product, string $tone): string
    {
        return "Generate a product description for:\n\n"
             . "Title: {$product['title']}\n"
             . "Price: {$product['price']}\n"
             . "Category: " . ($product['product_type'] ?? 'General') . "\n"
             . "Tags: " . implode(', ', $product['tags'] ?? []) . "\n"
             . "Current description: " . ($product['body_html'] ?? 'None') . "\n\n"
             . "Tone: {$tone}\n"
             . "Length: 2-3 paragraphs with bullet points for key features.";
    }
}

Handling Token Limits and Errors

// app/Services/DescriptionGenerator.php (extended)
public function generateWithRetry(Shop $shop, array $product, string $tone = 'professional', int $maxRetries = 2): ?string
{
    for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
        try {
            $description = $this->generate($shop, $product, $tone);

            // Track usage for billing
            $shop->increment('ai_tokens_used', strlen($description));

            return $description;
        } catch (\OpenAI\Exceptions\ErrorException $e) {
            if (str_contains($e->getMessage(), 'rate_limit') && $attempt < $maxRetries) {
                sleep(pow(2, $attempt)); // Exponential backoff
                continue;
            }
            logger()->error('OpenAI generation failed', [
                'shop' => $shop->domain,
                'product' => $product['id'] ?? null,
                'error' => $e->getMessage(),
            ]);
            return null;
        }
    }
    return null;
}

2. React Embed in Shopify Admin with Polaris

Your app lives inside Shopify's admin as an embedded app. You need a React frontend using Shopify's Polaris component library.

Setting Up the Frontend

npm create vite@latest frontend -- --template react
cd frontend
npm install @shopify/polaris @shopify/app-bridge-react

The Description Generator UI

// frontend/src/components/DescriptionGenerator.jsx
import { useState } from 'react';
import {
    Card,
    TextField,
    Select,
    Button,
    TextContainer,
    SkeletonBodyText,
    Banner,
    Stack,
    Layout,
} from '@shopify/polaris';

export function DescriptionGenerator() {
    const [product, setProduct] = useState(null);
    const [tone, setTone] = useState('professional');
    const [generated, setGenerated] = useState('');
    const [loading, setLoading] = useState(false);

    const tones = [
        { label: 'Professional', value: 'professional' },
        { label: 'Casual', value: 'casual' },
        { label: 'Luxury', value: 'luxury' },
        { label: 'Technical', value: 'technical' },
        { label: 'Playful', value: 'playful' },
    ];

    const handleGenerate = async () => {
        setLoading(true);
        try {
            const response = await fetch('/api/generate-description', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]')?.content,
                },
                body: JSON.stringify({ product_id: product, tone }),
            });
            const data = await response.json();
            setGenerated(data.description);
        } catch (err) {
            console.error('Generation failed:', err);
        } finally {
            setLoading(false);
        }
    };

    return (
        <Layout>
            <Layout.Section>
                <Card sectioned>
                    <TextContainer>
                        <TextField
                            label="Product ID or Title"
                            value={product}
                            onChange={setProduct}
                        />
                        <Select
                            label="Tone"
                            options={tones}
                            value={tone}
                            onChange={setTone}
                        />
                        <Button primary onClick={handleGenerate} loading={loading}>
                            Generate Description
                        </Button>
                    </TextContainer>
                </Card>
            </Layout.Section>
            <Layout.Section>
                {loading ? (
                    <Card sectioned>
                        <SkeletonBodyText lines={6} />
                    </Card>
                ) : generated ? (
                    <Card sectioned title="Generated Description">
                        <div dangerouslySetInnerHTML={{ __html: generated }} />
                        <Stack distribution="trailing">
                            <Button onClick={() => navigator.clipboard.writeText(generated)}>
                                Copy
                            </Button>
                            <Button primary onClick={handleApply}>
                                Apply to Product
                            </Button>
                        </Stack>
                    </Card>
                ) : null}
            </Layout.Section>
        </Layout>
    );
}

Laravel API Endpoint

// app/Http/Controllers/Api/DescriptionController.php
namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Services\DescriptionGenerator;
use App\Models\Product;

class DescriptionController extends Controller
{
    public function __construct(
        private DescriptionGenerator $generator
    ) {}

    public function generate(Request $request)
    {
        $request->validate([
            'product_id' => 'required|string',
            'tone' => 'sometimes|in:professional,casual,luxury,technical,playful',
        ]);

        $shop = $request->attributes->get('shop');
        $product = Product::where('shop_id', $shop->id)
            ->where('shopify_product_id', $request->product_id)
            ->firstOrFail();

        $description = $this->generator->generateWithRetry(
            $shop,
            $product->toShopifyArray(),
            $request->tone ?? 'professional'
        );

        if (!$description) {
            return response()->json(['error' => 'Generation failed'], 500);
        }

        return response()->json(['description' => $description]);
    }
}

3. Bulk Generation with Queues

Merchants with 500+ products won't generate descriptions one at a time. Bulk generation is essential.

The Bulk Job

// app/Jobs/BulkGenerateDescriptions.php
namespace App\Jobs;

use Illuminate\Bus\{Batchable, Queueable};
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\{InteractsWithQueue, SerializesModels};
use Illuminate\Support\Facades\Bus;
use App\Services\DescriptionGenerator;
use App\Models\Product;
use App\Models\BulkJob;

class GenerateSingleDescription implements ShouldQueue
{
    use Batchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 2;
    public int $backoff = 10;

    public function __construct(
        public BulkJob $bulkJob,
        public int $productId
    ) {}

    public function handle(DescriptionGenerator $generator): void
    {
        if ($this->batch()?->cancelled()) {
            return;
        }

        $product = Product::find($this->productId);
        $description = $generator->generateWithRetry(
            $product->shop,
            $product->toShopifyArray(),
            $this->bulkJob->tone
        );

        if ($description) {
            $product->update(['generated_description' => $description]);
        }

        $this->bulkJob->increment('processed_count');
    }
}

Dispatching the Batch

// app/Http/Controllers/Api/BulkController.php
namespace App\Http\Controllers\Api;

use Illuminate\Support\Facades\Bus;
use App\Jobs\GenerateSingleDescription;
use App\Models\BulkJob;

class BulkController extends Controller
{
    public function start(Request $request)
    {
        $shop = $request->attributes->get('shop');

        $products = $shop->products()
            ->whereNull('generated_description')
            ->pluck('id');

        $bulkJob = BulkJob::create([
            'shop_id' => $shop->id,
            'total_count' => $products->count(),
            'processed_count' => 0,
            'tone' => $request->tone ?? 'professional',
            'status' => 'processing',
        ]);

        $jobs = $products->map(
            fn($id) => new GenerateSingleDescription($bulkJob, $id)
        );

        $batch = Bus::batch($jobs)
            ->name("bulk-descriptions-{$shop->id}")
            ->allowFailures()
            ->finally(function () use ($bulkJob) {
                $bulkJob->update(['status' => 'completed']);
            })
            ->dispatch();

        $bulkJob->update(['batch_id' => $batch->id]);

        return response()->json([
            'bulk_job_id' => $bulkJob->id,
            'total' => $products->count(),
        ]);
    }
}

This uses Laravel's job batching — you get progress tracking, cancellation support, and failure handling out of the box.

4. Usage-Based Billing

Shopify supports usage-based billing through the Billing API. You charge merchants based on how many descriptions they generate.

Setting Up a Usage Charge

// app/Services/ShopifyBilling.php
namespace App\Services;

use Illuminate\Support\Facades\Http;
use App\Models\Shop;

class ShopifyBilling
{
    public function createUsageRecord(Shop $shop, int $units, float $pricePerUnit = 0.05): void
    {
        $mutation = <<<'GraphQL'
        mutation appUsageRecordCreate($id: ID!, $description: String!, $price: Decimal!, $url: URL) {
            appUsageRecordCreate(input: {
                appSubscriptionLineItemId: $id
                description: $description
                price: { amount: $price, currencyCode: USD }
            }) {
                userErrors { field message }
                appUsageRecord { id }
            }
        }
        GraphQL;

        Http::withHeaders(['X-Shopify-Access-Token' => $shop->access_token])
            ->post("https://{$shop->domain}/admin/api/2024-01/graphql.json", [
                'query' => $mutation,
                'variables' => [
                    'id' => $shop->subscription_line_item_id,
                    'description' => "AI Description Generation ({$units} descriptions)",
                    'price' => $units * $pricePerUnit,
                ],
            ]);
    }
}

Tracking Usage Locally

Keep a local counter so you can bill at intervals:

// In your GenerateSingleDescription job, after successful generation:
$shop->increment('descriptions_generated');
$shop->increment('ai_credits_used');

// Check if we should bill
if ($shop->ai_credits_used >= $shop->billing_threshold) {
    app(ShopifyBilling::class)->createUsageRecord(
        $shop,
        $shop->ai_credits_used
    );
    $shop->update(['ai_credits_used' => 0]);
}

Pricing Model Example

A simple model that works well:

• Free tier: 10 descriptions/month
• Pro: $9.99/month base + $0.05 per description over 100
• Enterprise: $49.99/month with 1,000 descriptions included

Putting It All Together

The flow looks like this:

1. Merchant selects products in your Polaris UI
2. Frontend calls your Laravel API
3. API dispatches batch jobs to the queue
4. Each job calls OpenAI, saves the description, and tracks usage
5. Usage gets billed through Shopify's Billing API
6. Merchant sees progress and reviews generated descriptions in the UI

The stack is: Laravel (backend) + React/Polaris (frontend) + Redis (queues) + OpenAI (AI) + Shopify Billing (payments).

One last piece of advice: always show the merchant a preview before applying AI-generated content to their live store. Give them a copy button and an "Apply" button. Trust builds retention.

Ship it, iterate on the prompts, and watch the usage metrics. The quality of your AI output is your product's moat — invest time in prompt engineering.

TL;DR: A complete walkthrough of building a Shopify custom app with Laravel — from Partner account setup to OAuth, webhooks, order syncing, and deployment. Includes real cost breakdown. If you're searching for a practical Shopify + Laravel tutorial, this is it.

Why I Chose This Stack

I had a client who needed a custom Shopify app — not a public app store listing, but a private app for their specific store. They needed order syncing, inventory management, and a custom admin dashboard. I'm a Laravel developer, so the choice was easy.

Laravel gives you queues, migrations, Eloquent, and a clean HTTP client. Shopify gives you well-documented REST and GraphQL APIs. Together, they move fast.

Step 1: Shopify Partner Account Setup

Before writing any code, you need a Shopify Partner account.

1. Go to partners.shopify.com and sign up (free)
2. Navigate to Apps → Create app
3. Choose Custom app (not public — this is for a single merchant)
4. Note down your API Key and API Secret
5. Set your App URL to your Laravel app's URL (must be HTTPS)
6. Set your Redirect URL to https://yourdomain.com/auth/callback
7. Configure your scopes — I used: read_products,write_products,read_orders,write_orders,read_inventory

Creating a Development Store

In your Partner dashboard:

1. Go to Stores → Add store → Development store
2. Name it, pick a purpose, and create it
3. This gives you a free test store with all Shopify features

Step 2: Laravel Project Setup

laravel new shopify-sync-app
cd shopify-sync-app

Install dependencies:

composer require guzzlehttp/guzzle
composer require predis/predis # For Redis queues

Configure your .env:

APP_URL=https://yourdomain.com

SHOPIFY_API_KEY=your_api_key_here
SHOPIFY_API_SECRET=your_api_secret_here
SHOPIFY_SCOPES=read_products,write_products,read_orders,read_inventory

QUEUE_CONNECTION=redis
CACHE_DRIVER=redis
SESSION_DRIVER=redis

Database Migration

// database/migrations/create_shops_table.php
Schema::create('shops', function (Blueprint $table) {
    $table->id();
    $table->string('domain')->unique();
    $table->string('access_token')->encrypted();
    $table->string('scopes')->nullable();
    $table->timestamp('installed_at')->nullable();
    $table->timestamps();
});

// database/migrations/create_synced_orders_table.php
Schema::create('synced_orders', function (Blueprint $table) {
    $table->id();
    $table->foreignId('shop_id')->constrained()->onDelete('cascade');
    $table->string('shopify_order_id')->unique();
    $table->string('order_number');
    $table->string('email')->nullable();
    $table->decimal('total_price', 10, 2);
    $table->string('financial_status');
    $table->json('raw_data');
    $table->timestamp('shopify_created_at');
    $table->timestamps();
});

Run migrations:

php artisan migrate

Step 3: OAuth Implementation

Shopify's OAuth flow has two parts: the install redirect and the callback.

Routes

// routes/web.php
Route::get('/', function () {
    return view('welcome');
});

Route::get('/auth/install', [ShopifyController::class, 'install']);
Route::get('/auth/callback', [ShopifyController::class, 'callback']);

Controller

// app/Http/Controllers/ShopifyController.php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;
use App\Models\Shop;

class ShopifyController extends Controller
{
    public function install(Request $request)
    {
        $shopDomain = $request->query('shop');

        if (!$shopDomain || !preg_match('/^[a-zA-Z0-9\-]+\.myshopify\.com$/', $shopDomain)) {
            abort(400, 'Invalid shop domain');
        }

        $redirectUri = config('app.url') . '/auth/callback';
        $scopes = config('services.shopify.scopes');

        $authUrl = "https://{$shopDomain}/admin/oauth/authorize?" . http_build_query([
            'client_id' => config('services.shopify.key'),
            'scope' => $scopes,
            'redirect_uri' => $redirectUri,
            'state' => csrf_token(),
        ]);

        return redirect($authUrl);
    }

    public function callback(Request $request)
    {
        // Step 1: Verify HMAC
        $this->verifyHmac($request);

        // Step 2: Validate shop domain
        $shopDomain = $request->query('shop');
        if (!preg_match('/^[a-zA-Z0-9\-]+\.myshopify\.com$/', $shopDomain)) {
            abort(400, 'Invalid shop domain');
        }

        // Step 3: Exchange code for access token
        $response = Http::post("https://{$shopDomain}/admin/oauth/access_token", [
            'client_id' => config('services.shopify.key'),
            'client_secret' => config('services.shopify.secret'),
            'code' => $request->query('code'),
        ]);

        if ($response->failed()) {
            abort(500, 'Failed to get access token');
        }

        $accessToken = $response->json('access_token');

        // Step 4: Store the shop
        $shop = Shop::updateOrCreate(
            ['domain' => $shopDomain],
            [
                'access_token' => $accessToken,
                'scopes' => $response->json('scope'),
                'installed_at' => now(),
            ]
        );

        // Step 5: Register webhooks
        $this->registerWebhooks($shop);

        // Step 6: Perform initial sync
        $this->syncOrders($shop);

        return redirect("https://{$shopDomain}/admin/apps");
    }

    private function verifyHmac(Request $request): void
    {
        $hmac = $request->query('hmac');
        $params = collect($request->query())->except('hmac')->sortKeys();

        $message = $params->map(fn($value, $key) => "{$key}={$value}")->join('&');
        $computed = hash_hmac('sha256', $message, config('services.shopify.secret'));

        if (!hash_equals($hmac, $computed)) {
            abort(403, 'HMAC verification failed');
        }
    }

    private function registerWebhooks(Shop $shop): void
    {
        $webhooks = [
            ['topic' => 'orders/create', 'address' => config('app.url') . '/webhooks/orders'],
            ['topic' => 'orders/updated', 'address' => config('app.url') . '/webhooks/orders'],
            ['topic' => 'app/uninstalled', 'address' => config('app.url') . '/webhooks/uninstall'],
        ];

        foreach ($webhooks as $webhook) {
            Http::withHeaders(['X-Shopify-Access-Token' => $shop->access_token])
                ->post("https://{$shop->domain}/admin/api/2024-01/webhooks.json", [
                    'webhook' => array_merge($webhook, ['format' => 'json']),
                ]);
        }
    }
}

Step 4: Order Syncing

Initial Sync (Paginated)

// app/Services/OrderSyncService.php
namespace App\Services;

use Illuminate\Support\Facades\Http;
use App\Models\Shop;
use App\Models\SyncedOrder;

class OrderSyncService
{
    public function syncAll(Shop $shop): int
    {
        $count = 0;
        $url = "https://{$shop->domain}/admin/api/2024-01/orders.json?status=any&limit=250";

        while ($url) {
            $response = Http::withHeaders(['X-Shopify-Access-Token' => $shop->access_token])
                ->get($url);

            $orders = $response->json('orders', []);

            foreach ($orders as $order) {
                SyncedOrder::updateOrCreate(
                    [
                        'shop_id' => $shop->id,
                        'shopify_order_id' => (string) $order['id'],
                    ],
                    [
                        'order_number' => $order['order_number'],
                        'email' => $order['email'] ?? $order['contact_email'],
                        'total_price' => $order['total_price'],
                        'financial_status' => $order['financial_status'],
                        'raw_data' => $order,
                        'shopify_created_at' => $order['created_at'],
                    ]
                );
                $count++;
            }

            // Follow pagination link header
            $url = $this->getNextPageUrl($response->header('Link'));
        }

        return $count;
    }

    private function getNextPageUrl(?string $linkHeader): ?string
    {
        if (!$linkHeader) return null;

        preg_match('/<([^>]+)>; rel="next"/', $linkHeader, $matches);
        return $matches[1] ?? null;
    }
}

Webhook Handler for Real-Time Updates

// app/Http/Controllers/WebhookController.php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Jobs\ProcessOrderWebhook;
use App\Jobs\HandleAppUninstall;

class WebhookController extends Controller
{
    public function orders(Request $request)
    {
        $this->verifyWebhook($request);

        $shopDomain = $request->header('x-shopify-shop-domain');

        ProcessOrderWebhook::dispatch($shopDomain, $request->all());

        return response()->json(['received' => true], 200);
    }

    public function uninstall(Request $request)
    {
        $this->verifyWebhook($request);

        HandleAppUninstall::dispatch(
            $request->header('x-shopify-shop-domain')
        );

        return response()->json(['received' => true], 200);
    }

    private function verifyWebhook(Request $request): void
    {
        $hmacHeader = $request->header('x-shopify-hmac-sha256');
        $computed = base64_encode(
            hash_hmac('sha256', $request->getContent(), config('services.shopify.secret'), true)
        );

        if (!hash_equals($hmacHeader, $computed)) {
            abort(401);
        }
    }
}

// app/Jobs/ProcessOrderWebhook.php
namespace App\Jobs;

use App\Models\Shop;
use App\Models\SyncedOrder;

class ProcessOrderWebhook implements \Illuminate\Contracts\Queue\ShouldQueue
{
    public int $tries = 3;
    public int $backoff = 30;

    public function __construct(
        public string $shopDomain,
        public array $orderData
    ) {}

    public function handle(): void
    {
        $shop = Shop::where('domain', $this->shopDomain)->first();

        if (!$shop) return;

        SyncedOrder::updateOrCreate(
            ['shop_id' => $shop->id, 'shopify_order_id' => (string) $this->orderData['id']],
            [
                'order_number' => $this->orderData['order_number'],
                'email' => $this->orderData['email'] ?? null,
                'total_price' => $this->orderData['total_price'],
                'financial_status' => $this->orderStatus['financial_status'],
                'raw_data' => $this->orderData,
                'shopify_created_at' => $this->orderData['created_at'],
            ]
        );
    }
}

Step 5: Deployment

Server Requirements

• PHP 8.2+
• Redis (for queues and caching)
• MySQL 8.0+
• SSL certificate (Let's Encrypt is free)
• Supervisor for queue workers

Quick Deploy with a VPS

I used a $6/month DigitalOcean droplet. Here's the essentials:

# Clone and install
git clone your-repo
composer install --optimize-autoloader --no-dev
php artisan config:cache
php artisan route:cache
php artisan migrate --force

# Start queue worker
php artisan queue:work redis --tries=3 --daemon

Supervisor config for the queue worker:

[program:shopify-queue]
command=php /var/www/shopify-app/artisan queue:work redis --sleep=3 --tries=3
numprocs=2
autostart=true
autorestart=true

Cost Breakdown

Here's what it actually cost to build and run this app:

The only real cost is the server. Everything else is free or open source.

Lessons Learned

1. Always verify HMAC. Both on OAuth callback and on webhooks. Skip this and you're open to attacks.
2. Return 200 immediately from webhook endpoints. Queue everything. Shopify retries if you're slow.
3. Paginate carefully. Shopify returns max 250 orders per page. Use the Link header for pagination.
4. Handle the uninstall webhook. Clean up tokens and data when merchants uninstall.
5. Use Redis for queues, not the database driver. Database queues don't scale and cause locking issues.
6. Test with a development store first. Never test against a live merchant store.

Building a Shopify app with Laravel is straightforward once you understand the OAuth flow and webhook patterns. The initial setup takes a day, and the rest is building features on top of that foundation.

TL;DR: As a solo developer, I built and launched a SaaS MVP in two weeks using AI coding agents (Claude Code, Cursor, and GitHub Copilot). Here's the day-by-day breakdown of what I built, what the AI handled versus what I coded myself, and the real costs involved.

The Project

I wanted to build InvoiceFlow — a simple invoicing and billing dashboard for freelancers. The core features: create invoices, track payments, send payment reminders via email, and basic analytics. Nothing revolutionary, but something I could actually ship and charge for.

Tech stack: Next.js (frontend), Laravel (API), PostgreSQL, Stripe, and SendGrid.

Here's how it went.

Day 1-2: Planning and Setup

What I did:

• Wrote a 2-page spec document
• Designed the database schema on paper
• Set up GitHub repository
• Configured Next.js with TypeScript and Tailwind
• Bootstrapped Laravel API with Sanctum for auth

What the AI helped with:

• Cursor generated the initial Laravel project structure with migrations
• Copilot suggested the TypeScript types I'd need based on my spec

What I coded manually:

• The actual database schema (migrations)
• Auth flow logic (Sanctum tokens, middleware)
• Project architecture decisions

Time spent: ~6 hours total

Day 3-4: Database and Core Models

What I did:

• Created all Laravel migrations (users, clients, invoices, line items, payments)
• Set up Eloquent models with relationships
• Created Laravel Factories for testing data
• Wrote the base API structure

What the AI handled (Claude Code):

# I prompted: "Create a migration for invoices table with client_id, status, due_date, total_amount, notes"

Claude generated the full migration file with proper column types, indexes, and foreign key constraints.

# Then: "Create an Invoice model with relationships to Client and Payment"

Output: A complete Eloquent model with all relationships, casts, and query scopes.

# Finally: "Create factories for User, Client, Invoice, and Payment models"

Got back 4 factory files with realistic fake data generation.

What I coded manually:

• Custom query scopes (e.g., scopeOverdue(), scopePaid())
• Model accessors and mutators for calculated fields
• The actual business logic that would be hard for AI to infer

Time spent: ~4 hours

Day 5-6: Laravel API Endpoints

What I did:

• Built CRUD endpoints for clients, invoices, and payments
• Implemented invoice status transitions (draft → sent → paid)
• Added validation rules for all inputs
• Set up API rate limiting

What the AI handled:

This was where AI shined. I'd write a prompt like:

Create a full REST API controller for invoices with:
- index: paginate by user with filters for status and date range
- store: validate and create with line items in a transaction
- show: return invoice with client and payments
- update: allow status changes and note updates
- destroy: soft delete only for draft invoices

Claude Code generated:

// A complete 200-line controller with:
// - Form request validation classes
// - Proper HTTP status codes
// - Transaction wrapping for data integrity
// - Resource classes for consistent JSON responses
// - Error handling with proper messages

I did this for 5 different controllers. The AI saved me at least 10 hours of boilerplate.

What I coded manually:

• Complex business rules (e.g., "Can't change status from 'paid' to 'sent'")
• Edge case handling
• The actual API route definitions

Time spent: ~5 hours

Day 7-8: Next.js Frontend Setup

What I did:

• Set up React Query for data fetching
• Created authentication context and login form
• Built the main dashboard layout with sidebar navigation
• Set up routing with Next.js App Router

What the AI handled (Cursor):

Cursor's inline completion was perfect here. As I typed:

const fetchInvoices = async () => {
  const response = await fetch('/api/invoices')
  const data = await response.json()
  return data.data
}

Cursor suggested:

const { data: invoices, isLoading, error, refetch } = useQuery({
  queryKey: ['invoices'],
  queryFn: fetchInvoices,
  refetchOnWindowFocus: false,
})

It learned my patterns and consistently suggested the right React Query hooks.

What I coded manually:

• The overall component architecture
• State management decisions
• UI/UX flow and design system

Time spent: ~6 hours

Day 9-10: Invoice Builder UI

What I did:

• Built the invoice creation form
• Implemented dynamic line item addition/removal
• Added real-time total calculation
• Created client selector with search

What the AI handled:

I'd describe the UI component and Cursor would generate the boilerplate:

Create a form component with fields: client_id (select), due_date (date picker), 
line_items (dynamic array with description, quantity, rate), notes (textarea)

Got back a complete form with:

• React Hook Form integration
• Zod validation schema
• Dynamic field arrays for line items
• Auto-calculation for line item totals

What I coded manually:

• The visual design and Tailwind classes
• User experience details (e.g., focus states, error placement)
• Real-time calculation logic (total = Σ qty × rate)

Time spent: ~5 hours

Day 11: Stripe Integration

What I did:

• Set up Stripe Checkout for invoice payments
• Created Stripe webhook endpoints
• Handled payment success/failure events
• Updated invoice status on successful payment

What the AI handled:

Create a Stripe Checkout session controller that:
- Takes invoice_id as input
- Creates a checkout session with line items from the invoice
- Returns the checkout URL

Claude generated the full controller with proper error handling and Stripe configuration.

For webhooks:

Handle Stripe checkout.session.completed webhook:
- Verify signature
- Find the invoice by metadata.invoice_id
- Mark invoice as paid
- Create a payment record

Got webhook verification, event parsing, and database updates in one go.

What I coded manually:

• Stripe account setup and API key configuration
• Webhook signature verification (tricky to get right)
• Error handling for edge cases (duplicate webhooks)

Time spent: ~3 hours

Day 12: Email Notifications

What I did:

• Set up SendGrid for transactional emails
• Created email templates for invoice delivery and payment reminders
• Built a queued job system for email sending
• Scheduled daily reminders for overdue invoices

What the AI handled:

Create a Laravel mailable for invoice delivery with:
- Client name and company
- Invoice number, due date, total amount
- A "Pay Now" button linking to Stripe checkout
- Clean HTML template

Claude generated the mailable class and Blade template. Then:

Create a scheduled command that:
- Finds all overdue invoices (status = sent, due_date < today)
- Sends a reminder email to each client
- Logs sent reminders to avoid duplicates

Got back a console command with proper scheduling and query logic.

What I coded manually:

• SendGrid account setup and API configuration
• Email template design (HTML + CSS)
• The actual scheduling in Laravel's console kernel

Time spent: ~3 hours

Day 13: Polish and Bug Fixes

What I did:

• Fixed bugs discovered during testing
• Added loading states and error messages
• Improved mobile responsiveness
• Added basic analytics (total invoiced, total paid, outstanding)

What the AI handled:

Copilot was great for quick fixes. I'd notice a bug and start typing the fix, and it would complete it. For example, when invoice totals weren't updating after line item changes, Copilot suggested the useEffect dependency array fix.

What I coded manually:

• All debugging and bug fixes (AI can't debug what it doesn't see)
• UX polish (animations, transitions, hover states)
• Analytics queries and chart components

Time spent: ~6 hours

Day 14: Deployment and Launch

What I did:

• Set up Vercel for Next.js frontend
• Deployed Laravel API to a VPS with Forge
• Configured environment variables
• Set up SSL and custom domain
• Wrote documentation and onboarding guide
• Created a landing page with pricing

What the AI handled:

Not much here. Deployment is mostly infrastructure work that AI can't do. I did use Copilot for generating the .env.example file and some Docker configuration snippets.

What I coded manually:

• All deployment configuration
• DNS and SSL setup
• The landing page copy and design
• Documentation

Time spent: ~8 hours

What AI Actually Coded vs. What I Coded

AI's Contributions (≈60% of code):

My Contributions (≈40% of code, but 100% of decisions):

Cost Breakdown

So I spent about $57/month in recurring costs to build and run the MVP. The AI tools paid for themselves on day 3.

What Went Well

1. AI for boilerplate: Controllers, models, forms — AI generated these instantly
2. Consistent code style: AI followed my patterns after learning them
3. Quick iteration: I could prototype features in minutes, not hours
4. Documentation: AI wrote doc comments and READMEs I wouldn't have bothered with

What Didn't Work

1. Complex business logic: AI struggled with nuanced rules (e.g., "Only remind clients who haven't been reminded in 7 days")
2. Debugging: AI can't debug errors it can't see. I had to debug integration issues myself
3. UI polish: AI generated functional UI, but the "delight" came from my manual refinement
4. Deployment: Infrastructure is still a manual job

The Honest Take

Could I have built this in 14 days without AI? No way. It would have taken me 4-6 weeks, and I probably would have burned out halfway through.

Did AI replace me? No. I still made every architecture decision, handled all debugging, and polished the UX. AI was a force multiplier — it handled the boring stuff so I could focus on the hard stuff.

Verdict: AI coding agents don't replace developers. They make solo development viable. I shipped because I didn't get stuck writing boilerplate. I shipped because AI let me iterate fast enough that momentum carried me through to day 14.

If you're building a side project as a solo dev, get Cursor, Claude Code, or Copilot. Use them aggressively. They won't make you a 10x developer, but they'll make your 1x work go 3-5x faster. And sometimes, speed is the difference between shipping and not shipping at all.

Complete guide to automate Hashnode blog publishing using OpenClaw AI assistant.

Overview

This guide shows how to:

1. Set up Hashnode API credentials in OpenClaw
2. Use OpenClaw tools to publish blog posts
3. Automate RND reports and documentation publishing
4. Schedule automated posts

Prerequisites

• OpenClaw installed and running
• Hashnode account with blog
• Personal Access Token from Hashnode
• Basic knowledge of Markdown

Step 1: Store Hashnode Credentials

Create a credentials file in OpenClaw workspace:

# File: HASHNODE.md
nano ~/.openclaw/workspace/HASHNODE.md

Content:

# Hashnode Integration

## Blog Details
- **Blog URL:** https://yourblog.hashnode.dev
- **Personal Access Token:** your_token_here

## API Endpoint
- **GraphQL:** https://gql.hashnode.com/

## Publication ID
- **ID:** your_publication_id_here

Example:

# Hashnode Integration

## Blog Details
- **Blog URL:** https://notes.masud.pro/
- **Personal Access Token:** 046b05d8-dcfd-42a1-aec1-4e1dde05f740

## API Endpoint
- **GraphQL:** https://gql.hashnode.com/

## Publication ID
- **ID:** 6875dce83b0919f1c1394d62

Step 2: Test Connection

Ask OpenClaw to verify the connection:

Test my Hashnode API connection

OpenClaw will:

1. Read credentials from HASHNODE.md
2. Query Hashnode API
3. Return your blog details

Step 3: Publish a Post via OpenClaw

Simple Post

Publish a blog post with title "My First Post" and content:
# My First Post

This is my first automated post!

OpenClaw will:

1. Read credentials
2. Prepare GraphQL mutation
3. Publish to Hashnode
4. Return the post URL

Post with Metadata

Publish a blog post:
Title: "Building REST APIs with Laravel"
Content:
# Building REST APIs with Laravel

## Introduction
Laravel makes API development easy...

## Setup
1. Install Laravel
2. Configure database

## Endpoints
- GET /api/users
- POST /api/users
- PUT /api/users/{id}
- DELETE /api/users/{id}

Step 4: Batch Publish Multiple Posts

Create a JSON file with posts:

{
  "posts": [
    {
      "title": "Part 1: Getting Started",
      "content": "# Part 1\n\nContent here..."
    },
    {
      "title": "Part 2: Advanced Features",
      "content": "# Part 2\n\nContent here..."
    }
  ]
}

Ask OpenClaw:

Publish all posts from posts.json to Hashnode

Step 5: Automate RND Reports

Daily RND Report

Create a cron job in OpenClaw:

Create a cron job that runs every Friday at 5 PM to publish my weekly RND report

OpenClaw will:

1. Create a cron job
2. Run every Friday 17:00
3. Generate report from memory files
4. Publish to Hashnode automatically

Report Template

The RND report will include:

• Weekly progress summary
• Technical challenges solved
• Code snippets and examples
• Links to GitHub commits
• Next week's plan

Step 6: Memory-Based Publishing

OpenClaw can read your memory files and publish them:

Read memory/2026-04-09.md and publish a summary as a blog post

This creates:

• Title based on date
• Summary of key events
• Technical decisions
• Lessons learned

Step 7: Integration with Other Tools

Notion → Hashnode

Sync my Notion page "PQM Architecture" to Hashnode

GitHub → Hashnode

Publish my README.md from repo "fusion-cart" as a blog post

Daily Notes → Weekly Digest

Create a weekly digest from memory files and publish to Hashnode

Advanced Features

Custom Post Templates

Create templates in workspace:

# Template: Technical Post

## Problem
{{PROBLEM_STATEMENT}}

## Solution
{{SOLUTION}}

## Code
```{{LANGUAGE}}
{{CODE}}

Results

{{RESULTS}}

Ask OpenClaw:

Use the Technical Post template to publish my solution for "Fixing Laravel Queue Issues"

### SEO Optimization

Publish a post about "Laravel Performance Tips" with SEO meta tags

OpenClaw will add:
- Optimized title
- Meta description
- Tags/keywords
- OpenGraph tags

### Scheduled Publishing

Schedule this post for next Monday 10 AM: Title: "Weekly Tech Update" Content: # Weekly Update...

## Troubleshooting

### Issue: Token Not Found

**Error:** `No Hashnode credentials found`

**Solution:**
1. Check HASHNODE.md exists in workspace
2. Verify token is correct
3. Check file permissions

### Issue: Publish Failed

**Error:** `Failed to publish post`

**Solution:**
1. Check publication ID
2. Verify markdown format
3. Check API rate limits

### Issue: Cron Not Running

**Error:** `Cron job not executing`

**Solution:**
1. Verify cron job is enabled
2. Check gateway status: `openclaw gateway status`
3. Review cron logs: `openclaw cron list`

## Best Practices

1. **Test First:** Always test with a draft post
2. **Backup Content:** Keep markdown copies in workspace
3. **Version Control:** Track HASHNODE.md in git (exclude token!)
4. **Monitor Logs:** Check OpenClaw logs for errors
5. **Rate Limits:** Hashnode has API limits, don't spam

## Security Tips

1. **Never commit tokens:** Add HASHNODE.md to .gitignore
2. **Use environment variables:** For production setups
3. **Rotate tokens:** Update tokens regularly
4. **Limit permissions:** Use minimal scope tokens

## Example Workflow

Complete workflow for publishing a technical post:

```bash
# 1. Write content
cat > my-post.md << EOF
# My Technical Post

Content here...
EOF

# 2. Ask OpenClaw to publish
# (In chat interface)
Publish the content from my-post.md to Hashnode

# 3. OpenClaw responds with:
# ✅ Post published!
# URL: https://notes.masud.pro/my-technical-post

# 4. Verify in browser
# Open the URL to check

Next Steps

• Set up daily documentation automation
• Create weekly RND report cron
• Integrate with GitHub for release notes
• Build custom publishing workflows

Resources

• Hashnode GraphQL Docs: https://gql.hashnode.com/
• OpenClaw Documentation: https://docs.openclaw.ai
• Markdown Guide: https://www.markdownguide.org/

Complete guide to publish blog posts on Hashnode using GraphQL API.

Prerequisites

1. Hashnode account with a blog
2. Personal Access Token
3. Blog URL

Step 1: Get Your Hashnode Token

1. Go to Hashnode
2. Click on Settings → API Tokens
3. Click "Generate new token"
4. Copy the token (save it securely)

Step 2: Get Your Publication ID

Run this GraphQL query:

curl -X POST https://gql.hashnode.com/ \
  -H "Content-Type: application/json" \
  -H "Authorization: YOUR_TOKEN_HERE" \
  -d '{
    "query": "query { me { username publications(first: 10) { edges { node { id title url } } } } }"
  }'

Response:

{
  "data": {
    "me": {
      "username": "your-username",
      "publications": {
        "edges": [
          {
            "node": {
              "id": "6875dce83b0919f1c1394d62",
              "title": "Your Blog Title",
              "url": "https://yourblog.hashnode.dev"
            }
          }
        ]
      }
    }
  }
}

Copy the id field - this is your Publication ID.

Step 3: Prepare Your Blog Post

Write your content in Markdown format:

---
title: Your Post Title
---

# Introduction

Your content here...

## Features

- Feature 1
- Feature 2

## Conclusion

Wrap up!

Step 4: Publish the Post

Use this GraphQL mutation:

curl -X POST https://gql.hashnode.com/ \
  -H "Content-Type: application/json" \
  -H "Authorization: YOUR_TOKEN_HERE" \
  -d '{
    "query": "mutation PublishPost($input: PublishPostInput!) { publishPost(input: $input) { post { title url slug } } }",
    "variables": {
      "input": {
        "publicationId": "YOUR_PUBLICATION_ID",
        "title": "Your Post Title",
        "contentMarkdown": "# Your Post Title\n\nYour markdown content here..."
      }
    }
  }'

Response:

{
  "data": {
    "publishPost": {
      "post": {
        "title": "Your Post Title",
        "url": "https://yourblog.hashnode.dev/your-post-slug",
        "slug": "your-post-slug"
      }
    }
  }
}

Step 5: Delete a Post (Optional)

First, get the post ID:

curl -X POST https://gql.hashnode.com/ \
  -H "Content-Type: application/json" \
  -H "Authorization: YOUR_TOKEN_HERE" \
  -d '{
    "query": "query { publication(host: \"yourblog.hashnode.dev\") { posts(first: 10) { edges { node { id slug title } } } } }"
  }'

Then delete:

curl -X POST https://gql.hashnode.com/ \
  -H "Content-Type: application/json" \
  -H "Authorization: YOUR_TOKEN_HERE" \
  -d '{
    "query": "mutation RemovePost($input: RemovePostInput!) { removePost(input: $input) { post { slug } } }",
    "variables": {
      "input": {
        "id": "POST_ID_HERE"
      }
    }
  }'

Common Issues

1. Invalid Token

• Error: Unauthorized
• Solution: Check your token is correct and not expired

2. Wrong Publication ID

• Error: Publication not found
• Solution: Get your publication ID again from Step 2

3. Markdown Format

• Error: Invalid markdown
• Solution: Escape quotes and special characters properly

Example: Complete Script

Save this as publish.sh:

#!/bin/bash

TOKEN="your_token_here"
PUB_ID="your_publication_id"
TITLE="My New Post"
CONTENT="# My New Post\n\nThis is my content..."

curl -X POST https://gql.hashnode.com/ \
  -H "Content-Type: application/json" \
  -H "Authorization: $TOKEN" \
  -d "{
    \"query\": \"mutation PublishPost(\$input: PublishPostInput!) { publishPost(input: \$input) { post { title url slug } } }\",
    \"variables\": {
      \"input\": {
        \"publicationId\": \"$PUB_ID\",
        \"title\": \"$TITLE\",
        \"contentMarkdown\": \"$CONTENT\"
      }
    }
  }"

Make it executable:

chmod +x publish.sh
./publish.sh

Next Steps

Now you can:

• Automate with cron jobs
• Integrate with CI/CD
• Build custom tools
• Use with OpenClaw for AI-powered blogging

When I plugged in my NTFS drive, Ubuntu gave me errors like: Error mounting /dev/sdb2 at /media/fatboy/win_128: wrong fs type, bad superblock on /dev/sdb2, missing codepage or helper program

This usually happens when:

• NTFS support (ntfs-3g) is missing

• The drive was not safely removed in Windows (hibernated / Fast Startup enabled)

• The drive needs manual mounting instead of automatic GUI mounting

✅ Solution Overview

1. Install NTFS support (ntfs-3g)

2. Create a mount point (/media/$USER/win_128)

3. Mount the drive manually to test

4. Create a .desktop launcher file to mount with a click

5. Trust the launcher so GNOME lets it run

⚙️ Step 1: Install NTFS Support

sudo apt update
sudo apt install ntfs-3g

📂 Step 2: Create a Mount Point

sudo mkdir -p /media/$USER/win_128

💻 Step 3: Mount the Drive Manually

sudo mount -t ntfs-3g /dev/sdb2 /media/$USER/win_128
ls /media/$USER/win_128

🖥 Step 4: Create a Desktop Launcher

sudo nano ~/Desktop/mount_win_128.desktop

[Desktop Entry]
Version=1.0
Type=Application
Name=Mount Win_128
Comment=Mount NTFS partition win_128
Exec=sh -c 'pkexec mount -t ntfs-3g /dev/sdb2 /media/$USER/win_128'
Icon=drive-harddisk
Terminal=false
Categories=Utility;

🔒 Step 5: Allow Launching

chmod +x ~/Desktop/mount_win_128.desktop
gio set ~/Desktop/mount_win_128.desktop metadata::trusted true

🛑 Bonus: Unmount Shortcut

[Desktop Entry]
Version=1.0
Type=Application
Name=Unmount Win_128
Comment=Unmount NTFS partition win_128
Exec=sh -c 'pkexec umount /media/$USER/win_128'
Icon=media-eject
Terminal=false
Categories=Utility;

🛑 Bonus: Unmount Shortcut 2.0

sudo nano ~/Desktop/toggle_mount.desktop
sudo chmod +x ~/Desktop/toggle_mount.desktop
gio set ~/Desktop/toggle_mount.desktop metadata::trusted true

[Desktop Entry]
Version=1.0
Type=Application
Name=Toggle Win_128
Comment=Mount/Unmount NTFS partition win_128
Icon=drive-harddisk
Terminal=false
Categories=Utility;
Exec=sh -c 'MP="/media/$USER/win_128"; DEV="/dev/sdb2"; mkdir -p "$MP"; if mountpoint -q "$MP"; then pkexec umount "$MP" && notify-send "Win_128" "Unmounted $D>

🎯 Result Now I can mount and unmount my Windows partition with a single click.