Gatsby Development

TL;DR

What it is: Building static websites using Gatsby, a React-based framework that uses GraphQL to pull data from various sources and generates blazingly fast static HTML. You create performance-optimized sites that load quickly, rank well in search engines, and work seamlessly with modern development workflows.

What you'll do:

• Build websites using React components and Gatsby's static site generation
• Query data using GraphQL from CMSs, APIs, or file systems
• Optimize images, performance, and SEO using Gatsby's built-in tools
• Integrate headless CMS platforms for content management
• Deploy sites to hosting platforms like Netlify, Vercel, or Gatsby Cloud

Time to learn: 3-5 months if you already know React and practice 8-12 hours weekly. Add 2-4 months if you're new to React or need to learn GraphQL fundamentals first.

What you need: Solid React.js skills, JavaScript fundamentals, GraphQL basics, command-line comfort, Git knowledge, and understanding of web performance concepts and modern development workflows.

What This Actually Is

Gatsby development means building static websites using Gatsby, a React-based framework that generates HTML files at build time rather than serving pages dynamically. Unlike WordPress or traditional content management systems that build pages when visitors arrive, Gatsby pre-renders everything into static files during the build process.

Gatsby combines React's component-based architecture with GraphQL for data management and produces optimized static sites. It pulls data from multiple sources—headless CMSs, APIs, databases, or markdown files—processes everything through GraphQL, and outputs plain HTML, CSS, and JavaScript files that load extremely fast.

The framework became popular around 2018-2020 for its excellent performance, developer experience, and rich plugin ecosystem. Companies like Airbnb, Nike, and Figma have used Gatsby for marketing sites, documentation, and e-commerce storefronts because of its speed and SEO capabilities.

However, the framework currently faces uncertainty. After being acquired by Netlify in 2023, Gatsby's open-source development has slowed significantly with infrequent updates and reduced maintenance. The framework holds about 0.2% market share compared to Next.js's 2.1%, and developer adoption has declined. Despite these concerns, existing Gatsby sites continue running, and some companies still choose it for specific performance-sensitive applications.

You're working as a specialized React developer who knows how to leverage static site generation, GraphQL data layers, and performance optimization for projects where these strengths matter. Part of the job involves assessing whether Gatsby fits client needs or if alternatives like Next.js make more sense.

What You'll Actually Do

Project work begins with understanding client requirements and determining if Gatsby suits their needs. You'll discuss content sources, update frequency, required features, performance targets, and budget. Some projects need server-side rendering or dynamic functionality that Gatsby can't provide, while others are perfect candidates for static generation.

Most development work centers on building React components and page templates. You'll create reusable components for headers, footers, navigation, content sections, and interactive elements. Unlike traditional React apps, these components run at build time to generate static HTML, so you'll think carefully about what happens during build versus what happens in the browser.

GraphQL queries are fundamental to Gatsby development. You'll write queries to fetch data from content sources, transform that data, and feed it into React components. This includes page queries for specific pages, static queries for component data, and understanding Gatsby's data layer to structure information efficiently.

Content management integration connects clients' content with your Gatsby sites. You'll integrate headless CMS platforms like Contentful, Sanity, Strapi, or WordPress, configure source plugins to pull data into Gatsby's GraphQL layer, and map content fields to component props. Some projects use markdown files directly, others need sophisticated multi-source data aggregation.

Image optimization is a crucial part of Gatsby work. The framework includes powerful image processing through gatsby-plugin-image that creates responsive images, lazy loads content, and generates multiple formats automatically. You'll implement these optimizations to ensure fast load times and good user experience.

Plugin configuration and customization extends functionality. Gatsby's ecosystem includes thousands of plugins for SEO optimization, analytics, forms, search, and integrations with various services. You'll select appropriate plugins, configure them correctly, and sometimes modify plugin code or create custom plugins for specific requirements.

Performance optimization goes beyond images. You'll implement code splitting, prefetching for faster navigation, Progressive Web App features, and accessibility improvements. Gatsby provides tools for these optimizations, but you need to implement them thoughtfully for each project.

Deployment and build configuration rounds out most projects. You'll set up continuous deployment from Git repositories to hosting platforms, configure environment variables for API keys and secrets, optimize build processes that can take several minutes for large sites, and troubleshoot build failures when dependencies or data sources cause issues.

Testing and debugging in Gatsby's build environment requires specific approaches. You'll debug build-time errors versus runtime errors, handle differences between development and production builds, and ensure all data queries work correctly. Static site generation means catching errors before deployment rather than in production.

Skills You Need

React.js proficiency is absolutely essential. Gatsby is built on React, and you'll spend most of your time writing React components. You need solid understanding of components, props, state management, hooks, lifecycle methods, and React's component composition patterns. If you're not comfortable with React, learn it thoroughly before tackling Gatsby.

JavaScript fundamentals underpin everything else. You need strong ES6+ knowledge including arrow functions, destructuring, spread operators, async/await, promises, and module imports. Gatsby uses modern JavaScript throughout, and weak JavaScript skills will constantly trip you up.

GraphQL knowledge is required since Gatsby uses GraphQL for its entire data layer. You need to understand queries, fragments, variables, and how GraphQL's type system works. You don't need expert-level GraphQL skills, but you should read, write, and debug queries confidently. Gatsby's GraphQL implementation has specific conventions you'll learn through practice.

HTML and CSS fundamentals remain important even with React components. You're still outputting HTML and styling it with CSS. Understanding semantic HTML, CSS layout systems like Flexbox and Grid, responsive design principles, and CSS preprocessors like Sass helps you build better sites.

Command-line proficiency is necessary since Gatsby is a CLI-based tool. You'll constantly run commands to start development servers, run builds, debug issues, and manage dependencies. Comfort with terminal environments and troubleshooting command-line errors is essential for professional work.

Git version control is non-negotiable. Gatsby projects live in Git repositories, and modern deployment platforms trigger builds from Git commits. You need solid Git skills including committing, pushing, pulling, branching, merging, and resolving conflicts. Understanding Git workflows prevents deployment problems.

Web performance concepts help you leverage Gatsby's strengths. Understanding concepts like code splitting, lazy loading, critical rendering path, Time to Interactive, and Core Web Vitals helps you make smart optimization decisions. Gatsby provides tools, but you need to know when and how to use them.

Build processes and tooling knowledge helps troubleshoot issues. Gatsby uses webpack internally and has complex build pipelines. While you don't need webpack expertise, understanding build processes, dependency management with npm or yarn, and how modern JavaScript tooling works prevents confusion when things break.

API integration skills come up frequently. You'll connect Gatsby sites to REST APIs, GraphQL APIs, third-party services, and various data sources. Understanding authentication, API rate limits, error handling, and asynchronous data fetching is important for complex projects.

Getting Started

Install Node.js and npm if you don't have them already, then install the Gatsby CLI globally. Follow Gatsby's official Quick Start guide to create your first site and understand the basic workflow. Don't skip the official tutorial even if you know React—Gatsby has specific patterns and conventions.

Ensure your React skills are solid before diving deep into Gatsby. If React concepts like components, props, state, and hooks feel unfamiliar, spend time building React apps first. Gatsby adds complexity on top of React, so you need a strong React foundation.

Learn GraphQL basics through Gatsby's GraphQL tutorial and external resources. Gatsby's GraphQL playground lets you explore data and test queries interactively. Spend time understanding how GraphQL queries work, how to fetch nested data, and how fragments simplify repeated query patterns.

Build a simple blog as your first real project. Use gatsby-starter-blog, which provides a basic blog structure, then customize it. This teaches you Gatsby's file structure, how pages are created, how data flows through GraphQL queries, and how components render content. Start with small modifications before major changes.

Study Gatsby's documentation systematically, particularly sections on GraphQL data layer, image optimization, plugin usage, and build process. The docs are comprehensive but dense. Focus on concepts you'll use constantly rather than trying to memorize everything.

Work through three to five progressively complex projects. After your blog, build a portfolio site with multiple content types, then a business site with complex layouts and external data sources, then something with e-commerce integration using Shopify or another headless commerce platform. Each project should push your skills further.

Learn one headless CMS integration thoroughly. Choose Contentful, Sanity, Strapi, or headless WordPress, and build a complete project using it. Understanding CMS integration makes you valuable to clients who need visual content management. Study the source plugin configuration, content modeling, and how data maps to components.

Create a portfolio website showcasing your Gatsby work. Build it with Gatsby itself to demonstrate your skills. Include case studies explaining your technical approach, performance optimizations, and results for each project. Your portfolio is your primary marketing tool for attracting clients.

Join Gatsby communities on Discord, Reddit, or GitHub Discussions. Read through common questions, study how experienced developers solve problems, and ask questions when stuck. Community participation helps you learn faster and builds professional connections.

Understand the framework's current state and alternatives. Research concerns about Gatsby's maintenance, compare it with Next.js and other frameworks, and form informed opinions about when Gatsby makes sense. Clients will ask about framework choices, and you need thoughtful answers beyond "I know Gatsby."

Income Reality

Gatsby development income varies significantly based on your skill level, project complexity, client budgets, and how you find work. Understanding market rates helps set realistic expectations. These observations reflect what developers in the market experience, not guaranteed earnings.

Hourly rates for intermediate Gatsby developers typically fall in the $45-$75 range according to freelance platform data. Expert-level developers with strong portfolios command $60-$100 per hour. Entry-level developers charge less, while specialists combining Gatsby with design or backend skills charge more. However, most projects are priced per project rather than hourly.

Simple website projects pay $1,500-$3,500. These include small business sites, personal portfolios, or blogs with straightforward designs and basic content management. Clients want fast, professional sites without complex functionality. Projects typically take 1-2 weeks depending on design complexity, content volume, and client responsiveness.

Theme or starter customization work ranges from $800-$2,000. Someone has an existing Gatsby site but wants layout changes, new features, performance improvements, or integration additions. These projects are shorter, often completed in 3-7 days, but require solid understanding of Gatsby's architecture and component patterns.

E-commerce frontend projects using Gatsby with Shopify, BigCommerce, or other headless commerce platforms pay $3,000-$8,000. These involve product display, cart functionality, checkout integration, and performance optimization for large product catalogs. E-commerce clients value Gatsby's speed since faster sites convert better. Expect 3-6 weeks for complete implementations.

Content-heavy sites with complex data structures command $2,500-$6,000. Examples include documentation sites, publications with multiple content types, or company sites pulling data from multiple sources. These require sophisticated GraphQL queries, careful data modeling, and often search functionality. Timeline varies from 2-4 weeks based on content complexity.

Migration projects from WordPress, Jekyll, or other platforms to Gatsby pay $2,000-$5,000. Work involves content export and transformation, rebuilding designs in React components, implementing redirects for SEO preservation, performance optimization, and thorough testing. Clients choosing migration usually have specific performance or development workflow goals. These projects take 2-4 weeks typically.

Custom plugin development or complex functionality additions range from $1,000-$4,000 depending on scope. Creating custom source plugins to pull data from proprietary APIs, building specialized image processing pipelines, or implementing complex interactive features require deeper Gatsby knowledge and often Node.js skills for plugin development.

Ongoing maintenance retainers exist but vary widely. Some clients pay $400-$1,200 monthly for content updates, feature additions, dependency updates, and technical support. These relationships typically develop after successful project completion and depend on site complexity and update frequency.

Documentation sites for developer tools, APIs, or technical products pay $2,500-$7,000. Tech companies value Gatsby for documentation sites with good search, fast navigation, and version switching. These projects need clear information architecture, often MDX integration for interactive documentation, and careful performance optimization.

Monthly income potential depends heavily on project volume and pricing. Completing two $3,000 projects monthly yields $6,000. Three smaller $1,500 projects produces $4,500. The math is straightforward, but maintaining consistent client flow requires ongoing marketing and networking efforts.

Geographic location affects rates somewhat since work is fully remote. However, clients in the US, Canada, and Western Europe typically have larger budgets than clients elsewhere. Your rates should reflect your skill level and value provided more than your location, though market realities mean client location influences what you can charge.

The income ceiling for Gatsby-only work is moderate compared to full-stack development. Developers combining Gatsby with React app development, Node.js backends, or design skills earn significantly more. Others scale income by building agencies or productized services rather than custom freelance work.

Framework uncertainty affects long-term income potential. Gatsby's declining maintenance and market share mean fewer new projects specifically requesting it. Developers who position themselves as "React/Jamstack developers" who know multiple frameworks rather than "Gatsby specialists" maintain better income opportunities as the market evolves.

Where to Find Work

Freelance platforms list Gatsby projects though less frequently than general React or web development work. Upwork, Freelancer, and Toptal mention Gatsby developers specifically in their marketplaces. Search for "Gatsby developer," "React static site," "Jamstack developer," or "headless CMS" to find relevant projects. Set up alerts for these keywords so you catch new postings quickly.

Arc and Turing connect remote developers with companies needing specialized skills. Both platforms have sections for Gatsby or Jamstack developers. These platforms typically vet developers more carefully and often lead to higher-quality clients than general freelance marketplaces. The application process requires portfolio review and sometimes technical assessments.

Note: Platforms may charge fees or commissions. We don't track specific rates as they change frequently. Check each platform's current pricing before signing up.

Remote job boards sometimes list contract Gatsby positions. Check We Work Remotely, Remote OK, AngelList, and React Jobs for static site or Jamstack opportunities. Many listings are for full-time roles but contract and freelance positions appear regularly, especially from startups and agencies.

React job listings often accept Gatsby skills even when not explicitly mentioned. Many companies need React developers who can work across different frameworks. When applying to React positions, mention your Gatsby experience as additional specialized knowledge rather than your only skill.

Direct outreach to agencies building marketing sites works well. Digital agencies often need specialized help for performance-focused client projects. Research agencies that build websites for e-commerce, SaaS companies, or content-heavy businesses, then reach out explaining your Gatsby expertise for high-performance site needs.

E-commerce businesses represent strong prospects. Companies using Shopify, BigCommerce, or other headless commerce platforms often want faster storefronts. Research growing e-commerce companies with slow websites and pitch Gatsby as a solution for better performance and conversion rates. Frame discussions around business outcomes like faster page loads improving sales.

Content-focused companies like publications, blogs, and content platforms benefit from Gatsby's performance. Identify companies with content-heavy sites experiencing performance issues, high hosting costs, or complex WordPress setups. Offer free performance audits showing how Gatsby could improve their specific situation.

Marketing teams at tech companies sometimes need specialized help. SaaS companies, developer tools, and technical products often use Gatsby for marketing sites or documentation but lack in-house Gatsby expertise. Reach out to marketing managers or growth teams at companies using Gatsby, offering to augment their team for specific projects or maintenance.

Open-source projects occasionally need contributors. Search GitHub for Gatsby sites needing help, particularly documentation sites or community projects. Contributing to open-source Gatsby projects demonstrates expertise publicly and sometimes leads to paid work from companies behind those projects.

Developer communities on Reddit, Discord, and forums provide networking opportunities. Participate in Jamstack discussions, answer Gatsby questions, and share your work. Some developers find clients through community referrals or by demonstrating expertise publicly over time.

Your professional network matters more than most expect. Tell former colleagues, developer friends, and professional contacts about your Gatsby services. Personal referrals convert to clients more easily than cold outreach since trust exists. Someone you worked with years ago might need a fast marketing site for their new startup.

Common Challenges

Framework uncertainty creates practical concerns. Gatsby's reduced maintenance and declining adoption make some clients hesitant. You'll answer questions about the framework's future, whether it's still supported, and why it's appropriate despite concerns. Having thoughtful responses about Gatsby's continued functionality, its strengths for specific use cases, and alternative options shows professionalism.

Finding clients specifically seeking Gatsby is harder than finding general React or web development work. Most business owners haven't heard of Gatsby or static site generators. You'll spend time educating prospects about static sites, which slows sales cycles. Learning to communicate technical benefits—faster load times, lower hosting costs, better SEO—in business language helps overcome this.

Build times become problematic for large sites. Gatsby's build process can take several minutes or even longer for sites with thousands of pages or complex data sources. This impacts local development speed and deployment time. You'll need strategies for incremental builds, deferred static generation, or might need to recommend alternatives for very large sites.

React and GraphQL requirements create a steeper learning curve than simpler frameworks. Clients sometimes struggle to find developers, and you'll compete with developers learning newer frameworks like Next.js that have more momentum. Your value proposition needs to clearly articulate what Gatsby brings beyond just React knowledge.

Content management expectations don't align with static site reality. Clients expect WordPress-like admin panels for real-time content updates. Gatsby's static generation means content changes trigger rebuilds that take time. Integrating headless CMS solutions provides editing interfaces but adds complexity, cost, and doesn't eliminate build times.

Debugging build errors can be frustrating since issues often occur during the build process rather than runtime. GraphQL query errors, plugin conflicts, memory issues with large data sets, and environment-specific problems require systematic debugging approaches. Error messages aren't always clear about root causes or solutions.

Plugin ecosystem limitations appear in complex projects. While Gatsby has many plugins, the ecosystem faces reduced maintenance as the framework's momentum slows. Some plugins become outdated, conflict with newer Gatsby versions, or lack features you need. You'll sometimes write custom solutions or integrate external services when plugins fall short.

Dynamic functionality requires external services or client-side workarounds. Forms, comments, search, user authentication, and real-time features don't work natively in static sites. You'll integrate services like Formspree for forms, Algolia for search, Auth0 for authentication, or implement client-side solutions with serverless functions. Each integration adds complexity and dependencies.

Competition from Next.js and other frameworks offering both static and server-side rendering means Gatsby isn't the default choice anymore. Next.js provides more flexibility with the same React foundation, and many developers prefer it. You need to articulate clearly when pure static generation benefits clients versus when server-side options add value.

Keeping current with React ecosystem changes while maintaining Gatsby expertise requires continuous learning. React evolves quickly with new patterns, hooks, and best practices. Staying relevant means learning modern React while maintaining Gatsby-specific knowledge, even as the framework receives fewer updates.

Managing client expectations about what's possible with static sites prevents scope creep. Clients request features assuming dynamic capabilities like personalized content, user-generated content, or complex interactivity. Setting clear boundaries early about static versus dynamic functionality prevents frustration and budget overruns later.

Tips That Actually Help

Position yourself as a React/Jamstack developer who knows multiple frameworks rather than a Gatsby specialist. Market uncertainty makes specialization risky. Knowing Gatsby alongside Next.js, Remix, or Astro provides flexibility and more opportunities. Clients value developers who recommend appropriate tools rather than pushing one framework regardless of fit.

Master React thoroughly before marketing Gatsby services. Your React skills matter more than Gatsby-specific knowledge since React applies broadly while Gatsby skills are narrower. Strong React fundamentals make you valuable even as framework preferences shift and help you work faster with Gatsby's component patterns.

Build a component library and starter template for common project types. You'll implement the same features repeatedly—navigation, forms, image galleries, SEO optimization. Having tested, reusable code speeds up project work significantly and reduces bugs. Version control your starters and update them as you refine your approach.

Learn GraphQL beyond just Gatsby's implementation. Understanding GraphQL more broadly makes you valuable for other projects and helps you debug Gatsby's data layer more effectively. GraphQL skills transfer to other tools and frameworks increasingly using it.

Study Gatsby's image optimization deeply since it's a major selling point. Understanding gatsby-plugin-image, responsive images, lazy loading, and format optimization helps you deliver measurably faster sites. Being able to show clients concrete performance improvements justifies your rates and demonstrates expertise.

Use Gatsby Cloud or Netlify for deployments to leverage incremental builds and preview environments. These platforms optimize Gatsby builds and provide better debugging tools than basic hosting. Understanding deployment platform features makes you more efficient and helps clients see the value of premium hosting.

Create detailed documentation for every client project. Non-technical stakeholders need guides for adding content, triggering deployments, and understanding the Gatsby workflow. Good documentation reduces support requests and helps clients feel confident managing their sites between your involvement.

Test thoroughly across different scenarios before launching. Check all GraphQL queries, test with production data, verify image optimizations work correctly, ensure environment variables are configured, and test build processes end-to-end. Static site builds mean catching errors before deployment rather than fixing them in production.

Price based on value delivered and measurable outcomes. A Gatsby site that loads two seconds faster than the previous WordPress site, scores higher on Core Web Vitals, and reduces hosting costs provides quantifiable business value. Frame pricing conversations around these outcomes rather than hours worked.

Build relationships with React developers and agencies. They sometimes encounter projects better suited for static generation and need specialized help. Partnering where they handle ongoing app development and you handle static marketing sites benefits everyone. These referral relationships provide steadier work than hunting individual clients.

Stay informed about Gatsby alternatives and be ready to recommend them. Understanding when Next.js, Astro, Eleventy, or other frameworks better fit client needs demonstrates professional integrity. Clients appreciate honest advice, and sometimes recommending alternatives leads to referrals or future work when you are the right fit.

Track your actual project time even when charging per project. Understanding how long different tasks take improves future estimates, reveals your true hourly rate, and helps identify inefficiencies. Many developers undercharge because they don't accurately track time against project pricing.

Learning Timeline Reality

Learning Gatsby well enough for freelance work typically takes 3-5 months if you already have solid React knowledge and practice 8-12 hours weekly. This assumes you're comfortable with React components, state management, hooks, and JavaScript fundamentals.

If you're new to React, add 2-4 months to learn it first. Trying to learn React and Gatsby simultaneously leads to confusion about which concepts belong to which tool. Build several React projects before starting Gatsby so React patterns feel natural.

GraphQL learning adds time if it's completely new. Most people pick up enough GraphQL for Gatsby work within 2-3 weeks of focused practice. You don't need deep GraphQL expertise, just understanding of queries, fragments, and Gatsby's specific GraphQL patterns.

The first month with Gatsby focuses on basics assuming you know React. You'll install Gatsby, understand project structure, build simple sites with gatsby-starter templates, learn GraphQL fundamentals for data querying, and deploy basic projects to hosting platforms. Build 2-3 simple sites following tutorials to cement these concepts.

Months two and three involve deeper learning. You'll create custom page templates and components, work with source plugins for CMSs and data, implement image optimization and performance features, understand Gatsby's build process and static query differences, and integrate more complex data sources. Build increasingly complex projects that challenge your growing skills.

Months four and five focus on advanced topics and specialization. You'll develop custom plugins for unique requirements, optimize large sites with thousands of pages, master headless CMS integrations, learn deployment optimization strategies, and develop business skills for finding and managing clients. You're ready for professional work though continuous learning continues.

This timeline works with consistent, focused practice. Sporadic learning stretches the timeline significantly. Building actual projects rather than just following tutorials accelerates learning since you encounter and solve real problems rather than guided examples.

Your first client projects take longer than expected. Budget extra time for scope discussions, revisions, and unexpected challenges. By your third or fourth project, you'll work significantly faster as you internalize patterns, refine your process, and leverage your growing component library.

Factors that accelerate learning include strong React foundation, previous experience with GraphQL or other query languages, solid JavaScript skills, and learning by building diverse projects rather than repeating similar ones. Factors that slow learning include weak React fundamentals requiring constant backtracking, trying to learn too many technologies simultaneously, and avoiding official documentation in favor of random tutorials.

This timeline is an estimate based on typical learning patterns, not a guarantee. Your actual timeline depends on prior experience, time dedicated to deliberate practice, how effectively you learn from mistakes, and how quickly you grasp new concepts.

Is This For You

Gatsby development fits you if you enjoy working with modern React-based development and appreciate performance optimization. You should like problem-solving with component architecture, feel comfortable with GraphQL's data querying approach, and not mind working with build processes and developer tooling.

This works well if you want remote, flexible work. Most Gatsby projects don't require specific working hours—you deliver quality work by agreed deadlines. This makes it compatible with other commitments, different time zones, or non-traditional schedules. The fully remote nature means location doesn't limit opportunities.

You'll do well if you can explain technical concepts clearly to non-technical clients. Much of the work involves helping clients understand why static site generation benefits their specific situation, how build processes work, and what's possible within Gatsby's architecture. Strong communication skills matter as much as technical abilities.

This isn't ideal if you prefer simple, beginner-friendly frameworks. Gatsby requires solid React knowledge, GraphQL understanding, and comfort with modern JavaScript tooling. The learning curve is steeper than WordPress or simpler static site generators. If complex tooling frustrates you, consider alternatives.

Skip this if you're uncomfortable with framework uncertainty. Gatsby's reduced maintenance and declining market share create legitimate concerns about long-term viability. While existing sites continue working, betting your career exclusively on Gatsby carries risk. Choose this path only if you're willing to learn alternative frameworks alongside it.

This might not work if you need immediate income. Building skills takes 3-5 months assuming React knowledge, finding your first clients takes additional time, and you won't earn meaningful money during the learning period. Have alternative income while building skills and portfolio.

Consider whether you're genuinely interested in React, static site generation, and web performance optimization. If these technologies excite you intellectually, you'll push through learning challenges. If you're only here for money and have no interest in the tech, you'll likely burn out when things get difficult.

Gatsby development can provide solid supplementary income or even full-time work for skilled React developers who position themselves appropriately. The market is smaller and shrinking compared to Next.js or general React development, but niches remain where Gatsby's strengths—build-time optimization, plugin ecosystem, and straightforward static generation—provide clear value. Success requires both technical skills and honest assessment of when Gatsby fits client needs versus when alternatives make more sense.