Stack Innovations / Services / Web / Gatsby

Gatsby, with the data layer everywhere.

Gatsby is a React framework with a graphql data layer that treats every source — WordPress, Contentful, Markdown, a REST API, Shopify, your homegrown CSV — as the same content mesh. Query once, ship anywhere. We tune the schema, the plugin pipeline, the image pipeline, and the build. Predictable, fast, mature.

01 — In numbers

Six years shipping
the data layer.

Each stat is a Gatsby GraphQL type definition. Hover any to see the SDL it'd generate via schemaCustomization. Counters scrub with scroll.

site.projectsShipped
0+ Gatsby sites shipped
type Site {
  projectsShipped: Int!
    @min(value: 24)
}
site.contentNodes
0+ Content nodes modeled
type Site {
  contentNodes: Int!
    @min(value: 3200)
}
site.pluginsAuthored
0+ Plugins authored / forked
type Site {
  pluginsAuthored: Int
    @min(value: 64)
}
site.defaultBuilds
0★ Default-config Gatsby builds
type Site {
  defaultBuilds: Int
    @max(value: 0)
}
02 — What we build

A full-stack Gatsby practice.

Click the schema explorer on the left — the active capability opens in the GraphiQL-feeling editor. Each pane is a working pattern we've shipped.

Stack · Gatsby 5.x ~/stack/gatsby/gatsby-node.js build · 0 errors G S
graphql data layer · 142 types · 31 queries SHIPPED

GraphQL data layer, queried like a database.

uid: graphql.schema updated: 09:42 today by: stack-eng
summary · what this gets you

Gatsby's killer feature: every source becomes nodes in the same GraphQL schema. allMarkdownRemark, allWpPost, allContentfulArticle, allShopifyProduct — all queryable from any page or component, with refinements, filters, sorting, pagination.

items · what we customize
  • createSchemaCustomization · explicit types
  • Custom resolvers · cross-source joins
  • Fragments · reusable query parts
  • pageQuery for routes, useStaticQuery for components
  • Schema field-level deprecation & migration
content-mesh 5 active sources · 1 schema UNIFIED

Content mesh, five sources, one schema.

uid: mesh.sources updated: yesterday by: stack-eng
summary

One project pulls from WordPress (legacy posts), Contentful (marketing pages), Markdown (docs), a REST API (events), and Shopify (commerce). Gatsby normalizes them all into the same schema. Editorial keeps tools they know; engineers query one API.

items
  • gatsby-source-wordpress · WPGraphQL
  • gatsby-source-contentful · previews
  • gatsby-source-filesystem · Markdown / MDX
  • gatsby-source-shopify · products / collections
  • Custom source plugins for legacy systems
gatsby-plugin-image avif · webp · jpeg · blur-up OPTIMIZED

Image pipeline, the original.

uid: image.pipeline updated: 2d ago by: stack-eng
summary

Gatsby invented the modern image-pipeline pattern (Gatsby Image, then gatsby-plugin-image). One source image becomes responsive AVIF / WebP / JPEG sizes with blur-up placeholders, art direction, and lazy loading — all generated at build time, all queryable.

items
  • gatsbyImageData · responsive srcset
  • AVIF + WebP + JPEG fallback
  • Blur-up + dominant color placeholders
  • Art direction per breakpoint
  • CDN-ready · remote image transforms
performance LCP · CLS · INP · TTFB A-GRADE

Performance & SEO, baseline 100.

uid: perf.budget updated: 4d ago by: stack-eng
summary

Static HTML at build time + automatic prefetching of linked pages + tuned image pipeline + critical CSS inlining = honest Lighthouse 100s. We layer in JSON-LD, Open Graph, sitemaps, hreflang, canonical, and CI perf budgets that fail the build on regressions.

items
  • gatsby-plugin-react-helmet · per-page meta
  • gatsby-plugin-sitemap · auto-generated
  • JSON-LD schemas per content type
  • Critical CSS inlining
  • CI perf budget · fails on regression
plugins source · transformer · plugin CURATED

Plugin ecosystem, 3,200+ deep.

uid: plugins.curated updated: 1w ago by: stack-eng
summary

Gatsby's ecosystem is its moat. We curate a tight stack of source / transformer / plugin combinations per project, vet them for maintenance and bundle size, and write our own when no existing plugin fits. Forks pinned, patches in patches/.

items
  • Source plugins · vetted · pinned
  • Transformer chains · Markdown → MDX → AST
  • Custom plugins · onCreateNode hooks
  • Patches via patch-package
render-modes SSG · DSG · SSR per route HYBRID

DSG & SSR, render mode per route.

uid: render.mode updated: 2w ago by: stack-eng
summary

Static (SSG) for the marketing spine, Deferred Static Generation (DSG) for long-tail content that doesn't need to ship at every build, SSR for personalized routes — same project, same schema, different runtime per route. Build times stay sane on 100k+ page sites.

items
  • defer: true in createPage()
  • getServerData() for SSR routes
  • Build-time vs request-time data, per-route
  • Slices API · shared layouts cached
03 — Schema → query → data

Click a field.
The query rebuilds.

This is what makes Gatsby itself: every source flows into one typed GraphQL schema. Toggle fields in the schema explorer on the left — the query in the middle rebuilds, and the response on the right updates with realistic data from a fake content mesh. anime.js spring on toggle, Mo.js burst on run.

query · PageQuery

    
localhost:8000/___graphql live

      
0 fields 8ms · cached
04 — Why us

Stack Innovations vs the typical Gatsby build.

Same framework, two gatsby-config.js files. The diff tells the story.

typical/gatsby-config.js — default starter
module.exports = {
  siteMetadata: {
    title: 'Site',
    siteUrl: 'https://example.com',
  },
  plugins: [],
}

// no source plugins
// no transformers
// no image pipeline
// no schema customization
// shipped to prod — everywhere.
stack/gatsby-config.js — Stack Innovations
module.exports = {
  siteMetadata: {
    title: 'Stack Innovations',
    siteUrl: 'https://stackinnovations.com',
    organization: { /* JSON-LD */ },
  },
  graphqlTypegen: true,
  trailingSlash: 'never',
  plugins: [
    'gatsby-plugin-image',
    'gatsby-plugin-sharp',
    'gatsby-transformer-sharp',
    { resolve: 'gatsby-source-wordpress',
      options: { url: process.env.WP_URL } },
    { resolve: 'gatsby-source-contentful',
      options: { spaceId, accessToken } },
    'gatsby-source-filesystem',
    'gatsby-transformer-remark',
    'gatsby-plugin-mdx',
    'gatsby-plugin-sitemap',
    'gatsby-plugin-react-helmet',
    'gatsby-plugin-manifest',
  ],
}
typical · empty plugins, no sources Stack · full mesh, image pipeline, typegen, SEO
05 — Content mesh

Five sources,
one schema.

This is Gatsby's superpower. Multiple content sources flow into the unified GraphQL data layer; pages query whatever they need. Click a source on the left to toggle it — the schema rebuilds in real time, fields appear and disappear, particles flow along the active links.

graphql data layer 142 types
/ Home pageQuery
/p Product pageQuery + DSG
/b Blog pageQuery
Source → GraphQL GraphQL → Page click a source to toggle
06 — How it ships

Six weeks,
schema first.

  1. w 01

    Source audit + schema design

    Inventory every existing content source. Design the unified GraphQL schema that maps them. Lighthouse baseline.

  2. w 02

    Gatsby scaffold

    Gatsby 5 scaffolded, source / transformer / image plugins wired, environments, GraphQL typegen, CI perf budgets.

  3. w 02–04

    Queries + components + image

    Page queries, fragments, MDX content, image pipeline, custom transformers, schema customization for cross-source joins.

  4. w 04

    SEO + DSG

    Sitemaps, JSON-LD, hreflang, canonical, redirect map. DSG for long-tail routes, SSR for personalized routes.

  5. w 06

    Migration + launch

    Content migration via source plugins, redirects mapped. gatsby build, deploy, DNS cutover.

  6. ∞

    Care plan

    Gatsby version bumps, plugin upgrades, perf monitoring, monthly review. Features, not tickets.

Booking Q3 2026 · Avg engagement: 6 weeks · Reply within 24h