MC-Guide
Content Writing
Website 51: Webiny.com
How Can You Earn Money Writing For “webiny.com” Website
This guide shows you, step by step, how a beginner can learn to pitch and sell stories to webiny.com.
You will learn what Webiny.com wants, how to test your idea, how to write a pitch, and how payment roughly works. You can use this like a small SOP.
Guide: Learn Webiny (Get started), then write tutorials & earn
This long-form guide teaches you, step-by-step, how to learn Webiny’s open-source serverless CMS, build a small demo project, and convert that work into blog posts, guest articles, and paid tutorials.
It includes direct links to the official Webiny docs and program pages so you can follow exact installation steps, authoring rules, and the “Write with Webiny” contributor program. Read, build, write — and monetise.
Section 1 · Overview
What Webiny is (short, practical)
Webiny is an open-source, serverless content platform and CMS built to run on AWS serverless infrastructure. It combines a headless CMS, a page builder, a forms & file manager, and developer tools so teams can host content within their own cloud account and ship fast, scalable websites and digital experiences. :contentReference[oaicite:0]{index=0}
The Webiny documentation offers a “Get started” flow that helps you install, develop, and deploy your first Webiny project — which is the recommended path for beginners. :contentReference[oaicite:1]{index=1}
- Headless CMS — content models, revisions, localization, GraphQL APIs.
- Page builder — drag-and-drop page creation and pre-rendering.
- Form & file management — collect data and store assets.
- Developer framework — plugins, scaffolds, CI/CD, and a deploy system to AWS.
Because Webiny runs serverless and is open-source, it’s a great platform to write practical tutorials about deploying content platforms, building headless websites, performance tuning on AWS Lambda, and creating workflows that use GraphQL, S3, DynamoDB and more. Those are high-value, technical topics that readers (and paying publishers) seek. :contentReference[oaicite:2]{index=2}
Section 2 · Before you start
What you need (prerequisites & accounts)
Before following the official install / get-started guide, make sure you have the basics ready: a GitHub account, an AWS account (with the ability to create IAM roles — Webiny deploys into your AWS account), Node.js & Yarn installed locally, and a code editor (VS Code recommended). The official “Install Webiny” guide covers these steps precisely. :contentReference[oaicite:3]{index=3}
Short checklist (expand this into a local note you can tick off):
- GitHub account and basic git knowledge.
- AWS account with permissions to create/cloud resources (IAM, CloudFormation, S3, Lambda, API Gateway).
- Node.js (LTS) and Yarn or npm installed.
- Terminal / command line comfort (running commands, reading logs).
- Optional: Docker for local testing (some workflows use Docker; docs will note it where required).
Section 3 · Install & create a first project
Follow-along: the minimal steps (summary)
This section gives a compact, readable summary — but always run the official commands in the docs (links below). If anything here differs from the docs, follow the docs. :contentReference[oaicite:5]{index=5}
Create an AWS user and set up credentials
Create an IAM user for deployments (programmatic access) and store the access key and secret locally using the AWS CLI (aws configure). This keeps your main account safer and is exactly what the deploy docs expect.
Scaffold a new Webiny project
Run the official scaffold command described in the docs to create a new Webiny project template. Example (see docs for exact latest CLI command): yarn create webiny-project my-site (or the docs’ recommended CLI). The scaffold will create the monorepo structure with packages for the API, admin, apps, and more. :contentReference[oaicite:6]{index=6}
Start dev server & explore Admin
Use the project’s dev commands to run the Admin app locally, create content models in the headless CMS UI, and test saving content. This is where you get familiar with the interface: content models, fields, locales, and the GraphQL playground.
Deploy to your AWS account
Follow the docs to deploy to AWS — the project uses CloudFormation and serverless patterns (Lambda, API Gateway, DynamoDB, Elasticsearch/OpenSearch, S3). The docs have a step-by-step “Install Webiny” section with exact commands and environment variables. :contentReference[oaicite:7]{index=7}
Section 4 · Build a simple demo project
Project idea: Blog with Page Builder + Headless CMS
You will build a tiny blog that uses Webiny’s CMS for posts (headless) and the Page Builder to assemble landing pages. This demo gives you working code, screenshots, and talking points for at least one detailed tutorial article.
Why this demo is article-friendly
- It covers content modelling (CMS) — a concept many readers search for.
- It shows how to deliver pages using Page Builder — practical and visual.
- It requires deploy steps — useful for a “deploy to AWS” walkthrough.
- It can include performance notes (serverless behavior) — advanced readers care.
Step-by-step mini-plan (detailed)
- Create a content model – add a “Post” model with fields: title, slug, excerpt, body (rich text), cover image, tags, published (boolean), publishDate.
- Fill sample content – use the Admin to create 3 sample posts, include images (upload to file manager) and different tags to show filtering.
- Build a small frontend – a Next.js or simple React app that requests content via Webiny’s GraphQL API and renders posts. (Webiny’s docs show how to query the headless CMS API.)
- Use Page Builder – create a marketing landing page in Admin containing a “Latest posts” block that pulls data from the CMS or links to your frontend.
- Deploy & test – deploy to AWS and verify the API, Admin, and website work; document common gotchas you encountered.
- Take screenshots of each Admin step (content model, creating an entry, file uploads) — readers love visuals.
- Keep code snippets minimal and runnable — share a GitHub repo or CodeSandbox.
- Test the GraphQL queries in the Playground and paste the exact queries into your article.
- Note any AWS resource names and costs (approximate) so readers understand the deploy side.
When you’re done, you’ll have: (1) a public GitHub repo with code; (2) screenshots and short screencasts; (3) GraphQL queries; and (4) a verified deployed demo you can link to in an article — everything editors ask for in tutorial submissions.
Section 5 · Deploy & hosting options
Deploy targets: Self-hosted (your AWS account) vs Webiny Cloud / Enterprise
Webiny is designed to run on serverless infrastructure — the recommended and common pattern is to deploy to your own AWS account using the official deployment scaffolds. Webiny also offers hosting and Enterprise plans (check their pricing and product pages for up-to-date options). :contentReference[oaicite:9]{index=9}
- Full control — data lives in your AWS account (S3, DynamoDB, Lambda, etc.).
- Good for learning and production — deployment scripts handle most complexity.
- Requires understanding of AWS resources and monitoring costs.
- Managed option for teams who prefer not to operate AWS infra directly.
- Check Webiny’s official product/pricing pages for current offerings and features. :contentReference[oaicite:10]{index=10}
For an article that teaches beginners, document the self-hosted AWS deploy path (because it teaches infra concepts) and mention the managed option as an alternative — link to Webiny’s pricing/product pages so readers can compare.
Section 6 · How to write a tutorial article from your demo
Article structure (proven template that editors like)
A clear, consistent structure helps editors and readers. Use this outline for your first Webiny tutorial article:
- Headline + quick one-line value — what will the reader learn in one sentence?
- Short intro & motivation — explain the problem and why Webiny is a good fit.
- Prerequisites — list required skills, accounts, and versions.
- Step-by-step guide — split into 5–10 sections (content model, admin steps, queries, frontend, deploy).
- Complete code — include a GitHub repo link and highlight the most important files.
- Results & testing — screenshots, GraphQL responses, and verifications.
- Wrap-up & next steps — suggestions for improvements and links to Webiny docs for advanced topics.
- Short paragraphs, clear headings, and inline code blocks (not huge dumps).
- Provide copy-paste code snippets and a working repository link.
- Add alt text to images and make sure your screenshots are readable on mobile.
- Test every command and command output — editors check that examples actually work.
When referencing official concepts or commands, link directly to the Webiny docs pages you used (for example the “Get started” and “Install Webiny” pages). This gives editors confidence and helps readers continue learning. :contentReference[oaicite:11]{index=11}
Section 7 · Monetisation: Write with Webiny & other paths
How you can earn from Webiny-focused writing
Webiny runs a “Write with Webiny” program inviting technical authors to contribute content and (in some cases) receive compensation. If you produce accurate, helpful, and well-documented tutorials about Webiny, you can apply to their contributor program. Make sure to read the program page to learn submission rules, payment terms, and content focus. :contentReference[oaicite:12]{index=12}
- Write with Webiny — submit tutorials to their program (see docs & program page). :contentReference[oaicite:13]{index=13}
- Freelance tutorials & consulting — use your Webiny samples to attract clients who need a CMS or serverless site built.
- Paid guest posts & platform articles — many tech sites pay for deep tutorials; your Webiny piece is a strong sample.
- Courses & workshops — expand a long tutorial into a paid course on platforms like Gumroad or Teachable.
- Use article bylines to get freelance leads and company outreach.
- Build an email list from tutorial readers and sell premium guides or consulting.
- Create a paid template or plugin for Webiny users and promote it via your article.
Action plan: write one high-quality Webiny tutorial, publish it on your blog or Dev.to, then pitch the same piece (or an improved version) to Webiny’s “Write with Webiny” program or other dev publications. Keep a public GitHub repo — it’s often the deciding factor for paying editors.
Section 8 · Pitch template & checklist
A simple pitch you can reuse (email or program form)
Use this short pitch template when contacting editors or filling a contributor form. Keep it concise, show your sample work, and explain the value for readers.
Subject: Tutorial pitch — “Build a serverless blog with Webiny (headless CMS + Page Builder)”
Body:
- Quick intro: “Hi — I’m [Name], I build serverless sites and developer tutorials. I’d like to propose a hands-on tutorial that shows readers how to model content in Webiny’s headless CMS, create a simple frontend using GraphQL, and deploy to AWS.”
- One-sentence angle: “Readers will learn how to ship a production-ready blog with Webiny and understand the AWS serverless pieces behind it.”
- Outline: bullet 5–8 section headings (content model, Admin, queries, frontend, deploy, test, SEO).
- Links: link to your writing samples, GitHub repo for the demo, and any past published pieces.
- Closing: “Thanks — I can send a full draft or an outline if you’re interested.”
Section 9 · Promotion & SEO — get your article read
Turn a tutorial into a steady income stream
Writing the article is half the job. Promotion determines reach. Here are practical steps that work for technical tutorials.
Optimize for search
Pick one clear keyword phrase (e.g., “Webiny headless CMS tutorial” or “deploy Webiny to AWS”). Use it in the title, first paragraph, headings, image alt text, and meta description. Add structured data if the platform supports it.
Share code & repo
Publish your demo on GitHub with a clear README and “Copy & Run” instructions. Readers are likelier to follow tutorials when the code works out of the box.
Repurpose content
Make a short thread for Twitter/X, a summarized LinkedIn post, and a 3–5 minute screencast for YouTube. Each platform brings different readers and potential clients.
Guest posts & syndication
After publishing on your blog, pitch the piece (or a tailored version) to Webiny’s program and other developer sites. Syndicate where allowed and always follow reposting/exclusivity policies.
If your article is accepted by Webiny’s program, that both pays (when applicable) and boosts visibility — include that option when you pitch. :contentReference[oaicite:14]{index=14}
Section 10 · Resources, links & further reading
Direct links to official docs, repos, and useful pages
- Get Started — Webiny Docs (Welcome). :contentReference[oaicite:15]{index=15}
- Install Webiny — Install & deploy guide. :contentReference[oaicite:16]{index=16}
- Overview & features (Page Builder, Headless CMS). :contentReference[oaicite:17]{index=17}
- Write with Webiny — contributor program. :contentReference[oaicite:18]{index=18}
- Webiny GitHub (webiny-js repo). :contentReference[oaicite:19]{index=19}
- Webiny examples repo (demos). :contentReference[oaicite:20]{index=20}
Final · Action checklist (use this each project)
Checklist: From demo → article → pitch
FAQ & common gotchas
Short answers to questions beginners ask
More resources
Handy links & community
- Get started — Webiny Docs. :contentReference[oaicite:25]{index=25}
- Write with Webiny — contributor program. :contentReference[oaicite:26]{index=26}
- Webiny GitHub repo — webiny-js. :contentReference[oaicite:27]{index=27}
- Webiny examples & demos. :contentReference[oaicite:28]{index=28}
- Install Webiny (exact deploy commands). :contentReference[oaicite:29]{index=29}
- Webiny features overview. :contentReference[oaicite:30]{index=30}
- Webiny pricing & Cloud options. :contentReference[oaicite:31]{index=31}