SEO blogs

.optimize-cache.json

@@ -346,6 +346,8 @@
   "images/blog/client-vs-server-components-react/cover.png": "b7ae8b7614902c8b4dd7826d59cfdb36db9abbe27bde99b3deb69c4bf178f425",
   "images/blog/cloud-beta.png": "7e44c7c7108d43bfcc77ba0c9910bfb14ba208bf559863d91610b29fc07da87c",
   "images/blog/cloud-pricing.png": "2018d3cd01b12c289c3f66b780ff8518a13fc44da58efb19420fc67e367dc8cf",
+  "images/blog/cname-flattening-for-appwrite-sites/cover.png": "612a77f799df64b9407ba37f64ca4acf2f4772b5e883de00102b0b606b60e674",
+  "images/blog/common-appwrite-mistakes-and-how-to-avoid-them/cover.png": "c1d0620fa048cfeacdf4b55ebdc176acf3587e9effe7bc5be88599624c343f45",
   "images/blog/community-pr.png": "112e1637eb62a95da227bb45bfe18a474cdd86b078877e21ae5ee57bfc959e29",
   "images/blog/community-pr1.png": "22362832160073257e59cec48d4bea2bdd92139a6d1ee409c66a51cb1e2ccc47",
   "images/blog/comparing-functions/1.png": "0c1add3fc0112aab08dc28188f8f997dcb20338e516db685284e6251145d5cb0",

src/lib/actions/analytics.ts

@@ -59,9 +59,14 @@ export type TrackEventArgs = { name: string; data?: object };
 export const trackEvent = (eventArgs?: string | TrackEventArgs): void => {
     if (!eventArgs || ENV.TEST) return;
 
-    const path = page.route.id?.replace(/\(([^()]*)\)/g, '') ?? '';
+    const path = page.url.pathname;
+    const route =
+        page.route.id
+            ?.replace(/\/\([^/]+\)/g, '') // remove grouped segments including leading slash
+            .replace(/\/{2,}/g, '/') ?? ''; // normalize accidental double slashes
     const name = typeof eventArgs === 'string' ? eventArgs : eventArgs.name;
-    const data = typeof eventArgs === 'string' ? { path } : { ...eventArgs.data, path };
+    const data =
+        typeof eventArgs === 'string' ? { path, route } : { ...eventArgs.data, path, route };
 
     if (ENV.DEV || ENV.PREVIEW) {
         console.log(`[Analytics] Event:`, name, data);

src/routes/blog/post/announcing-appwrite-pro/+page.markdoc

@@ -32,7 +32,7 @@ Pro gives you much more room and flexibility to build, scale, and maintain your
 - **Free**
 - **$15 per member per month**
 ---
-- Unlimited projects (never paused)
+- Unlimited projects
 - Unlimited projects (never paused)
 ---
 - 5GB bandwidth

src/routes/blog/post/appwrite-compared-to-supabase/+page.markdoc

@@ -180,7 +180,6 @@ Here’s a table that compares both Appwrite and Supabase:
 | Serverless functions runtimes | 10+ languages supported | Only 1 language officially supported |
 | Self-hosting / Cloud | Self-hosting and Cloud available | Self-hosting and Cloud available |
 | Supported programming languages | Supports [SDKs](/docs/sdks) in 10 languages JavaScript, Python, PHP, Kotlin, Dart | Supports SDKs in 6 languages |
-| Pausing of projects | Free projects are not paused ever | Free projects are paused after 1 week of inactivity |
 | Functions marketplace | Has a marketplace featuring a variety of function templates and integrations such as Discord bots, payments with Stripe, ChatGPT API, etc. | No functions marketplace |
 | Permissions | A simple-to-use permissions system that is consistent across all Appwrite products | Complex permissions system that needs knowledge of SQL to get started |
 | Messaging providers | 10 providers covering SMSes, emails, and push notifications | Zero |

src/routes/blog/post/appwrite-for-startups-ship-faster-without-backend-headaches/+page.markdoc

@@ -0,0 +1,83 @@
+---
+layout: post
+title: "Appwrite for Startups: Ship Faster Without Backend Headaches"
+description: Learn how Appwrite helps startups move from idea to launch faster by handling authentication, databases, storage, and backend workflows in one place. This guide shows why teams choose Appwrite to cut complexity, reduce development time, and stay focused on building the product instead of managing backend headaches.
+date: 2026-03-17
+cover: /images/blog/appwrite-for-startups-ship-faster-without-backend-headaches/cover.png
+timeToRead: 5
+author: atharva
+category: startup
+featured: false
+unlisted: true
+---
+
+Every startup faces the same trap: you have a product idea, a tight runway, and limited engineering hours. Instead of building the thing that makes your company unique, your team spends weeks wiring up authentication, designing database schemas, configuring file storage, and stitching together deployment pipelines.
+
+That backend plumbing is necessary. But it's not what differentiates your product. For an early-stage team, every week spent on infrastructure is a week not spent on features, user feedback, or growth.
+
+This is the core problem [Appwrite](https://cloud.appwrite.io/) solves. It gives startups a complete backend platform so you can skip the repetitive groundwork and focus on what actually matters: shipping your product.
+
+# The hidden cost of building your backend from scratch
+
+Building a custom backend sounds like the right move when you're starting out. Full control, no dependencies, no vendor constraints. But that control comes with serious overhead.
+
+Authentication alone can take weeks to build properly. You need password hashing, session management, OAuth integrations, rate limiting, and multi-factor authentication. Then you need to maintain all of it as security standards evolve. One mistake in any of these areas can compromise your users' data.
+
+Multiply that across databases, file storage, serverless functions, and hosting. A small team can easily spend months on backend infrastructure before writing a single line of product code. For startups, time is the scarcest resource. The question isn't whether you *can* build it yourself. It's whether you *should*.
+
+# Authentication that works out of the box
+
+[Appwrite Auth](/docs/products/auth) handles the entire authentication lifecycle with a few lines of code. You get email and password login, phone authentication, OAuth2 with 30+ providers (Google, GitHub, Apple, and more), magic URL login, and anonymous sessions.
+
+For teams that need custom authentication flows like Web3 wallets or enterprise SSO, Appwrite supports custom tokens that let you plug in your own logic. Security features like rate limiting, multi-factor authentication, and session management are built in. You don't need to think about password storage or token rotation.
+
+# A database you can set up in minutes
+
+Designing and optimizing a database is one of the most time-consuming parts of backend development. [Appwrite Databases](/docs/products/databases) simplifies this with a document-based model that you can configure through the console or API.
+
+Create collections, define attributes, set up indexes, and start querying data immediately. The built-in permission system lets you control access at the document level without writing custom middleware.
+
+If your app outgrows Appwrite's built-in database or you need a specialized solution, you can [integrate external databases](/blog/post/integrate-sql-nosql-vector-graph-or-any-database-into-your-appwrite-project) like PostgreSQL, MongoDB, or vector databases into your project. There's no lock-in forcing you to stay on one system.
+
+# File storage without the infrastructure headaches
+
+File uploads, image processing, and access control are features most apps need but few teams enjoy building. [Appwrite Storage](/docs/products/storage) provides secure file storage with built-in compression, encryption, and image transformations.
+
+Upload files in chunks for better performance, resize and crop images directly through the API, and set granular permissions per file. For mobile users on slow connections, Appwrite supports resumable uploads so users don't lose progress if their connection drops.
+
+This replaces what would otherwise be a custom integration with S3 or Google Cloud Storage, a separate image processing pipeline, and a layer of custom access control logic.
+
+# Serverless functions for custom backend logic
+
+Not everything fits into a pre-built API. When you need custom backend logic, [Appwrite Functions](/docs/products/functions) lets you deploy serverless functions in the language your team already uses: Node.js, Python, Dart, Ruby, PHP, and more.
+
+Functions can be triggered by HTTP requests, scheduled events, or Appwrite system events. This makes them useful for processing webhooks, sending notifications, running background jobs, or integrating with third-party APIs. You write the code and push it. Appwrite handles the runtime, scaling, and execution.
+
+# Deploy and host with Appwrite Sites
+
+Building a backend is only half the problem. You also need somewhere to deploy your frontend. [Appwrite Sites](/docs/products/sites) gives you managed hosting with Git-based deployments, so pushing to your repository automatically deploys your site.
+
+Your entire stack, backend and frontend, lives in one platform. No separate hosting provider, no extra CI/CD pipeline to configure, no additional billing to track. For a startup trying to move fast, fewer moving parts means fewer things that can break.
+
+# Why startups choose Appwrite over alternatives
+
+Startups often evaluate Appwrite alongside Firebase, Supabase, and custom backend setups. A few things set Appwrite apart for early-stage teams:
+
+- **Open source**: Appwrite is 100% open source. You can inspect the code, contribute to it, and [self-host](/docs/advanced/self-hosting) if your requirements change.
+- **No vendor lock-in**: Your data stays yours. If you ever need to migrate, there are no proprietary formats or ecosystems trapping you in.
+- **All-in-one platform**: Auth, databases, storage, functions, and hosting in a single console. Fewer tools means fewer integration issues and less context switching.
+- **Predictable pricing**: Appwrite's [pricing](/pricing) is straightforward, with no surprise bills as your usage grows.
+
+Firebase is the most common comparison. While it offers a generous free tier, its proprietary ecosystem makes migration difficult, and pricing can spike unpredictably at scale. Appwrite gives you the same speed of development without the long-term trade-offs. For a deeper look at how [BaaS platforms compare to custom backends](/blog/post/baas-vs-custom-backend), that breakdown covers the trade-offs in detail.
+
+# Getting started with Appwrite for your startup
+
+Appwrite's [Startups Program](/startups) is built for early-stage teams. It includes cloud credits, priority support with a dedicated Discord channel, and access to the Scale plan so your team can build without worrying about infrastructure costs during your most critical growth phase.
+
+Here's how to get moving:
+
+- **Create your project** on [Appwrite Cloud](https://cloud.appwrite.io/) and follow the [quickstart guide](/docs/quick-starts) to connect your app
+- **Apply** to the [Startups Program](/startups) for credits, priority support, and a dedicated program manager
+- **Explore the docs** for [Auth](/docs/products/auth), [Databases](/docs/products/databases), [Storage](/docs/products/storage), and [Functions](/docs/products/functions) to see what fits your stack
+
+If your team is spending more time on backend plumbing than on your actual product, that's the problem Appwrite was built to solve. Skip the infrastructure grind and start shipping.

src/routes/blog/post/building-a-production-ready-backend-with-appwrite/+page.markdoc

@@ -0,0 +1,101 @@
+---
+layout: post
+title: Building a Production-Ready Backend with Appwrite
+description: Discover how to build a scalable, secure, and production-ready backend with Appwrite using the tools modern teams need from day one. This guide walks through the core services, best practices, and setup choices that help you launch confidently and grow without backend chaos.
+date: 2026-03-17
+cover: /images/blog/building-a-production-ready-backend-with-appwrite/cover.png
+timeToRead: 5
+author: atharva
+category: tutorial
+featured: false
+unlisted: true
+---
+
+Most teams don't struggle with building a backend. They struggle with building one that holds up. Authentication gets bolted on, database schemas grow without structure, file uploads break under load, and security becomes an afterthought patched in after the first incident.
+
+The result is months spent rebuilding what should have been right from the start. Appwrite gives you a structured foundation for auth, databases, storage, serverless functions, and more, so you can ship with confidence on day one instead of firefighting later.
+
+# Why "production-ready" matters from the start
+
+A backend that works in development and a backend that works in production are two different things. The gap between them is where most projects lose time.
+
+Production-ready means your auth handles edge cases like expired sessions and brute-force attempts. It means your database enforces permissions at the row level, not just in your frontend code. It means your file storage serves assets through a CDN and your serverless functions recover gracefully from failures.
+
+If you treat these as "later" problems, you end up rewriting core infrastructure under pressure. Building on a platform that handles these concerns from the start removes that risk entirely.
+
+# Authentication that covers real-world scenarios
+
+User auth is the first thing you build and the first thing attackers probe. Appwrite's [Auth service](/docs/products/auth) supports over 30 OAuth providers, email/password, phone OTP, magic links, anonymous sessions, and [custom token flows](/blog/post/building-custom-auth-flows) for integrating with external identity systems.
+
+What makes it production-grade:
+
+- **Multi-factor authentication (MFA)** is built in, not bolted on
+- **Session management** handles token rotation, expiry, and device tracking automatically
+- **Password security** uses Argon2 hashing with breach detection and strength configuration
+- **Teams and labels** let you model role-based access without building a permissions system from scratch
+
+You configure these through the Appwrite Console or SDKs. No custom middleware, no third-party auth libraries to maintain.
+
+# Structured databases with enforced permissions
+
+Appwrite [Databases](/docs/products/databases) give you structured collections with defined schemas, query support, pagination, and relationships between documents. You can model one-to-one, one-to-many, and many-to-many relationships directly in Appwrite, reducing data redundancy and keeping your schema maintainable.
+
+The critical production detail is **document-level permissions**. Every document can have its own read and write rules, so access control lives in your data layer, not just your application code. This means a misconfigured frontend route cannot expose data it should not.
+
+Other features that matter at scale:
+
+- **Indexes** for fast query performance as your data grows
+- **Atomic operations** for counters and fields that multiple users update simultaneously
+- **Realtime subscriptions** via [Appwrite Realtime](/docs/apis/realtime) so your UI reflects changes within milliseconds
+
+# File storage with access control and delivery
+
+Appwrite [Storage](/docs/products/storage) handles file uploads, downloads, and serving with built-in permissions per bucket and per file. You get image manipulation (resize, crop, format conversion) through simple API parameters, which eliminates the need for a separate image processing pipeline.
+
+For production workloads, **file tokens** let you generate temporary, scoped access links for sensitive assets. Combined with bucket-level permissions, you have fine-grained control over who accesses what, without exposing raw storage URLs.
+
+# Serverless functions for custom backend logic
+
+Not every backend operation fits neatly into CRUD. Payment processing, third-party API calls, data transformations, and scheduled jobs all need a place to run. [Appwrite Functions](/docs/products/functions) give you isolated, auto-scaling containers triggered by HTTP requests, database events, schedules, or SDK calls.
+
+Key decisions for production functions:
+
+- **Choose the right runtime.** Appwrite supports Node.js, Python, Go, PHP, Dart, Bun, Deno, and more. Compiled languages like Go have faster cold starts for latency-sensitive endpoints.
+- **Keep functions focused.** One function per responsibility makes debugging, scaling, and updating significantly easier. Read our [serverless functions best practices](/blog/post/serverless-functions-best-practices) guide for a deeper breakdown.
+- **Use environment variables** for API keys and secrets. Never hardcode credentials in function source code.
+- **Connect to Git** for automatic deployments. Push to your repo, and Appwrite deploys the new version without manual intervention.
+
+# Messaging for user communication
+
+[Appwrite Messaging](/docs/products/messaging) supports email (via SMTP providers like Mailgun or SendGrid), SMS (Twilio, Vonage, MSG91), and push notifications (FCM, APNs). Instead of integrating three separate services with three different APIs, you configure providers once and send through a unified interface.
+
+This is particularly useful for transactional messages like password resets, order confirmations, and security alerts, all of which are table stakes for any production application.
+
+# Hosting with Appwrite Sites
+
+If your frontend needs a home, [Appwrite Sites](/docs/products/sites) provides hosting with Git-based deployments, global CDN distribution, DDoS protection, a web application firewall, and automatic TLS. It supports frameworks like Next.js, Nuxt, SvelteKit, and Astro out of the box.
+
+Having your frontend and backend on the same platform simplifies deployment pipelines and reduces the number of services you manage. Instant rollbacks let you recover from bad deployments in seconds.
+
+# Putting it into practice
+
+A production-ready backend is not just about which services you use. It is about how you configure them. Here is a checklist for teams going live with Appwrite:
+
+- **Lock down permissions early.** Set document-level and bucket-level permissions before writing frontend code, not after.
+- **Enable MFA** for admin accounts and sensitive user actions.
+- **Use API keys with minimal scopes.** Grant only the permissions each function or service actually needs.
+- **Set up realtime subscriptions** where your UI needs live data, rather than polling endpoints on intervals.
+- **Monitor function logs** in the Console to catch errors before users report them.
+- **Automate deployments** by connecting your Git repository to both Functions and Sites.
+
+# Getting started with Appwrite
+
+The fastest way to start is through [Appwrite Cloud](https://cloud.appwrite.io/), which gives you a managed instance without infrastructure setup. If your team needs full control over the hosting environment, Appwrite is open-source and [self-hostable](/docs/advanced/self-hosting) with Docker.
+
+From there, pick the service that matches your most immediate need and build outward:
+
+- [Auth quick start](/docs/products/auth/quick-start) for setting up user login
+- [Databases quick start](/docs/products/databases/quick-start) for structuring your data
+- [Functions quick start](/docs/products/functions/quick-start) for running custom backend logic
+- [Sites quick start](/docs/products/sites/quick-start) for deploying your frontend
+- [Appwrite Discord](https://appwrite.io/discord) for community support