Hasura Tutorials

Hasura end to end — instant GraphQL over Postgres, permissions and JWT auth, relationships, Actions, event triggers, migrations and CI/CD, and shipping to production. Every v2 example is taken from a real short-let booking app, and every topic also covers what changes in v3 (DDN).

• Hasura – Interview Questions
  The questions Hasura interviews actually ask, answered the way you would say them out loud. How Hasura generates a schema without resolvers, how permissions really work and why relationships do not cascade them, when to reach for an Action instead of a mutation, what an event trigger guarantees, the n+1 question, and the one that separates people who have shipped it: what you turn off before going to production.
• Hasura v3 (DDN) – Data Modeling with HML
  v3's metadata in depth, because in v3 the metadata is the product. Every object kind and what it is for — `DataConnectorLink`, `ObjectType`, `Model`, `Command`, `Relationship`, the boolean-expression, aggregate and order-by types, the three permission kinds, and the global config objects — worked through by modelling the same booking schema the v2 half of this track uses.
• Hasura v3 (DDN) – Getting Started, and Upgrading from v2
  The v3 half of the track in one piece. What a supergraph, a subgraph and a data connector are, the whole `ddn` walkthrough from `supergraph init` to a running local engine, and what the generated project tree actually contains. Then the part most people arrive for: what an existing v2 project has to become, which concepts carry over, and which ones — event triggers most sharply — simply do not.
• Hasura – Deployment
  Getting it running somewhere that is not your laptop. The environment variables that actually matter in production, running the engine on Docker or Kubernetes with health checks and more than one replica, database connection pooling and why it bites before anything else does, zero-downtime metadata changes, and where Hasura Cloud saves you work. Then DDN and Private DDN in v3.
• Hasura – Logging, Metrics and Tracing
  Knowing what your API is doing once real traffic hits it. The log types Hasura can emit and which ones are worth turning on, reading a query log to find the slow operation rather than guessing, the health and metrics endpoints, and tracing a request across Hasura and the service behind an Action. Plus what changes in v3.
• Hasura – Securing It for Production
  The checklist between a working Hasura and one you can put on the internet. Turning the console and introspection off, keeping the admin secret out of everything a client can read, why an unauthenticated request is not the same as a blocked one, restricting what the engine can reach at the database level, and the allow-list and rate-limiting features that need Enterprise — said plainly rather than assumed.
• Hasura – Caching and Performance
  Making it fast, and knowing what to measure first. Reading the SQL Hasura generates with `EXPLAIN`, the indexes that decide whether a filter is instant or a table scan, why deep nesting costs more than it looks, and the row limits that stop one query taking the database down. Also RESTified endpoints for clients that want a URL, and a straight account of which caching features need Enterprise.
• Hasura – Migrations, Metadata and CI/CD
  How a schema change gets from your laptop to production without anyone clicking in a console. What the Hasura CLI's migrations, metadata and seeds directories each hold, why metadata and migrations must move together, and the awkward question of who owns the schema when your ORM already runs its own migrations. Then a pipeline that applies both on merge, and the v3 equivalent built on `ddn supergraph build`.
• Hasura – Event Triggers and Scheduled Triggers
  Running code when data changes, without polling. Event triggers fire a webhook on insert, update or delete and retry it with a backoff; scheduled triggers do the same on a cron or at a one-off future time. Delivery guarantees, why your handler must be idempotent, and how to inspect and replay a failed event. Shown on a real bookings table — and with the awkward v3 news stated plainly: event triggers are still work in progress and cron triggers are not supported at all.
• Hasura – Remote Schemas and Federation
  Stitching an existing GraphQL API into Hasura's schema so clients see one graph instead of two. Adding a remote schema, the namespacing and type-collision problems that follow, remote relationships that join a database row to a field on another service, and how permissions and header forwarding work across the boundary. Then v3, where this stops being a bolt-on and becomes what the supergraph is.
• Hasura – Actions
  Actions are how anything Hasura cannot generate gets into the same GraphQL schema: you declare a type, point it at an HTTP endpoint, and it appears alongside the generated fields. Custom types, the request payload Hasura sends, forwarding client headers so your handler still knows who is calling, permissions, and error shapes. Shown with a real Action in front of a FastAPI endpoint, and its v3 replacement — a `Command` on a business-logic connector.
• Hasura – Authorization and Permissions
  The most important chapter in the track, because a mistake here is a data breach rather than a bug. Roles, row-level filters, column allowlists and session variables, worked through four real roles. Three traps with teeth: `admin` is reserved and cannot be given permissions, roles do not inherit from each other, and permissions do not cascade through relationships. Then `TypePermissions` and `ModelPermissions` in v3.
• Hasura – Authentication
  Hasura does not log anyone in — it verifies a token somebody else issued, and getting that split right is most of the work. JWT mode versus webhook mode, the `x-hasura-*` claims a token has to carry, the admin secret and why it must never reach a browser, and the unauthorized role that decides what a visitor with no token can see. Shown with one JWT secret shared between Hasura and a FastAPI backend — then `AuthConfig` in v3, where the admin secret does not exist at all.
• Hasura – Subscriptions
  Live data over a websocket, wired into a real React app with Apollo Client. The difference between a live query and a streaming subscription, why a subscription is just a query you keep open, how Hasura multiplexes many clients onto few database polls, and the permission and cost questions that decide whether you should use one at all. Includes the auth handshake that trips everyone up.
• Hasura – Mutations
  Writing through the API. `insert`, `update`, `delete`, their `_one` variants, `returning`, upserts with `on_conflict`, and the fact that several mutations in one request run in a single transaction while several requests do not. Also the harder question this track's demo app answers with a deliberate no: which writes belong in Hasura at all, and which belong behind your own API.
• Hasura – Relationships and Nested Queries
  Relationships are what make a Hasura API worth using: one round trip returns a listing, its host, its photos and its reviews. Object versus array relationships, how foreign keys suggest them and why you can define one without a foreign key, filtering and ordering a parent by a child's column, and the n+1 question everyone asks. Plus the `Relationship` kind in v3 and what changes when the two sides live in different connectors.
• Hasura – Queries
  The query language you get for free. `where` with `_eq`, `_gt`, `_in`, `_like`, `_and`/`_or`/`_not`, then `order_by`, `limit`/`offset`, cursor pagination, aggregates and `distinct_on` — each shown with the real response from a running engine. Also the naming-convention setting that decides whether your fields come back `price_per_night` or `pricePerNight`, and what it looks like in v3.
• Hasura – Metadata Is the Source of Truth
  Hasura's schema is not in your database and not in your code — it is metadata, and understanding that one fact explains most of the product. What tracking a table means, why clicking in the console is fine until two people do it, and how to keep metadata in version control and apply it from a script. Then v3, where metadata stops being a live API and becomes `.hml` files you compile.
• Hasura – Installation and Your First Query
  Get an engine running and a real query answered in one sitting. The Docker Compose service that runs Hasura next to Postgres, why the database port inside the compose network is not the one you published, the admin secret and what it grants, and the console. Then the same thing in v3: installing the `ddn` CLI, `ddn supergraph init` and `ddn run docker-start`.
• Hasura – What It Is and Why It Exists
  Start here. What Hasura actually does — point it at a Postgres database and get a GraphQL API with filtering, pagination, relationships and permissions without writing a resolver — and, just as important, what it does not do. Why v2 and v3 (DDN) are two different products rather than two releases of one, the exact versions this track is written against, the booking app every example comes from, and the full lesson index in reading order.