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