docs: add marketing checklist

sources/academy/platform/get_most_of_actors/index.md

@@ -46,12 +46,6 @@ To help you succeed, we've created a comprehensive Actor marketing playbook. You
         to="/academy/actor-marketing-playbook/store-basics/how-actor-monetization-works"
         smallImage
     />
-    <Card
-        title="Actor success stories"
-        desc="Some developers have turned their Actors into profitable tools with steady user bases. This section shares real-world examples of what works, from product strategy to marketing tactics."
-        to="/academy/actor-marketing-playbook/store-basics/actor-success-stories"
-        smallImage
-    />
 </CardGrid>
 
 ## Actor basics

src/utils/devto-article-prompt.js

@@ -0,0 +1,80 @@
+export const DEVTO_ARTICLE_PROMPT = `Create a comprehensive "Best [CATEGORY]" roundup article optimized for dev.to that naturally promotes [YOUR PRODUCT/SERVICE] while providing genuine value to the developer community.
+
+Article requirements:
+- Title: "The [NUMBER] Best [CATEGORY] for Developers in [YEAR]" (dev-focused angle)
+- Word count: 1,500-2,000 words (dev.to readers prefer actionable, scannable content)
+- Include 6-8 solutions total
+- Feature [YOUR PRODUCT/SERVICE] as position #1
+- Friendly, developer-to-developer tone
+- Include pros/cons for each solution
+- Add quick comparison table
+- Include code examples or API snippets where relevant
+
+Your product details:
+- Product name: [YOUR ACTOR NAME]
+- Product URL: [YOUR APIFY STORE URL]
+- Key technical features: [LIST 3-5 FEATURES]
+- Main use cases: [WHAT PROBLEMS IT SOLVES]
+- Tech stack/Integration: [RELEVANT TECHNICAL DETAILS]
+- Readme content: [PASTE HERE YOUR README]
+
+Content structure:
+1. Direct, problem-focused introduction (100-150 words):
+   - Start with the problem developers face
+   - Why you researched these tools
+   - What you'll cover
+
+2. "What I looked for" - clear evaluation criteria developers care about (100 words):
+   - Performance
+   - Ease of integration
+   - Documentation quality
+   - Pricing
+   - Community/support
+
+3. Detailed tool reviews (200-250 words each):
+   - Brief overview and what makes it stand out
+   - Key features (bullet points)
+   - Developer experience highlights
+   - Pros (3-4 specific items)
+   - Cons (2-3 honest drawbacks)
+   - Best for: [use case]
+   - Quick start difficulty: [Easy/Moderate/Complex]
+   - Code example or integration snippet (if applicable)
+
+4. Quick comparison table - focus on specs developers care about
+
+5. "My recommendation" section - which tool for which scenario (150-200 words)
+
+6. Conclusion with TL;DR and call-to-action (100 words)
+
+Writing guidelines:
+- Write like you're advising a fellow developer - casual and helpful
+- Be genuinely objective about all tools
+- Show real strengths of competitors (devs can smell BS)
+- For [YOUR PRODUCT], focus on technical advantages and developer experience
+- Include practical examples and real use cases
+- Use code blocks for any technical examples (specify language for syntax highlighting)
+- Use H2 (##) and H3 (###) markdown headers
+- Keep paragraphs short and scannable
+- Add emoji sparingly where natural (dev.to community uses them but don't overdo it)
+
+Technical credibility:
+- Mention actual testing or experience where possible
+- Include specific metrics (response times, ease of setup, etc.)
+- Reference documentation quality
+- Discuss integration complexity honestly
+- Mention any gotchas or limitations
+
+SEO optimization:
+- Use target keyword "[CATEGORY]" 8-12 times naturally
+- Include variations like "best [category] tools", "[category] for developers", "[category] API"
+- Add semantic keywords related to your technical domain
+- Use keywords in subheadings
+
+dev.to-specific elements:
+- Suggest 4 relevant tags (most important to least, e.g., #webdev, #api, #tools, #productivity)
+- Include a cover image description/suggestion
+- Write an engaging first paragraph that shows up in feed previews
+- Add a brief "Discussion prompt" at the end to encourage comments (e.g., "Which tool do you use? Let me know in the comments!")
+
+Please generate the complete article now in markdown format with proper heading hierarchy.`;

src/utils/devto-tutorial-prompt.js

@@ -0,0 +1,140 @@
+export const DEVTO_TUTORIAL_PROMPT = `Create a step-by-step tutorial showing developers how to use my Apify Actor to achieve [SPECIFIC OUTCOME], optimized for dev.to.
+
+Tutorial Requirements:
+- Title: "How to [ACHIEVE SPECIFIC OUTCOME] with [YOUR ACTOR NAME]" (clear, action-oriented)
+- Word count: 1,200-2,000 words (thorough but scannable)
+- Step-by-step format walking through using the Actor
+- Include screenshots suggestions and what users will see
+- Conversational, developer-to-developer tone
+- Focus on practical usage and configuration
+- Include tips and optional features
+
+Your Actor details:
+- Actor name: [YOUR ACTOR NAME]
+- Actor URL: [YOUR APIFY STORE URL]
+- Actor README: [PASTE YOUR ACTOR'S README OR KEY SECTIONS]
+- Main use case: [WHAT PROBLEM IT SOLVES]
+- Key features: [LIST 3-5 MAIN FEATURES]
+- Output format: [WHAT DATA/RESULTS USERS GET]
+
+Content structure:
+1. Introduction (100-150 words):
+   - Hook: Start with what readers will accomplish
+   - Why this Actor is useful/who it's for
+   - What they'll learn by the end
+   - Time estimate (e.g., "⏱️ This takes about 10 minutes")
+
+2. Prerequisites (50-100 words):
+   - Free Apify account (mention you can sign up with email or GitHub)
+   - Any other requirements
+   - No coding required (if applicable)
+
+3. "What you'll achieve" overview (100-150 words):
+   - Brief description of the end result
+   - What data or outcome they'll get
+   - Example use case
+
+4. Step-by-step tutorial using the Actor:
+
+   Step 1: Access [YOUR ACTOR NAME]
+   - Instructions: "Go to the [Actor Name] page on Apify Store to try it for free."
+   - Mention account creation (email or GitHub)
+   - Explain they'll be redirected to Apify Console
+   - What to expect: "You'll see the Actor's input configuration page"
+   - Screenshot suggestion: Actor page or Console view
+
+   Step 2: Configure [Primary Input/Settings]
+   - Explain the main input field(s) based on your README
+   - Provide specific examples (like "bagel" and "New York")
+   - Explain what the Actor will do with this input
+   - Show different options if your Actor has multiple input methods
+   - Tips for getting better results
+   - Screenshot suggestion: Input configuration
+
+   Step 3: [Additional Configuration - if applicable]
+   - Explain optional settings or advanced features
+   - When and why to use each option
+   - Examples of different configurations
+   - Best practices from your experience
+   - Screenshot suggestion: Advanced settings panel
+
+   Step 4: Run the Actor
+   - Click "Start" or "Run" button
+   - What happens: Status changes to "Running"
+   - How long it typically takes
+   - What's happening behind the scenes (briefly)
+   - "⚠️ Tip: You can leave the page and come back - the run will continue"
+
+   Step 5: View and download results
+   - Navigate to Storage tab or Results
+   - Preview the data
+   - Explain the data structure/fields
+   - Available export formats (JSON, CSV, Excel, etc.)
+   - How to filter or select specific data
+   - Screenshot suggestion: Results page with data
+
+   [Add more steps if your Actor has additional features]
+
+5. "Understanding your results" (150-200 words):
+   - Explain what each key field means
+   - How to interpret the data
+   - Example of actual output
+   - Common questions about results
+
+6. "Pro tips and advanced usage" (150-200 words):
+   - 3-5 tips for getting better results
+   - How to optimize for speed or cost
+   - Advanced configuration options
+   - Integration possibilities (API, webhooks, etc.)
+   - Common use cases from users
+
+7. "Troubleshooting common issues" (100-150 words):
+   - 2-3 common problems and solutions
+   - Where to check for errors
+   - How to get support
+
+8. "Next steps" (50-100 words):
+   - How to automate or schedule runs
+   - Integration ideas
+   - Link to documentation
+   - Encouragement to experiment
+
+Writing guidelines:
+- Write like you're helping a friend get started
+- Use "we" and "let's" language
+- Be encouraging and supportive
+- Explain what users will see at each step
+- Use bullet points for options or lists
+- Include emoji sparingly for visual breaks (✅, 🚀, ⚠️, 💡)
+- Format Actor/button names in bold
+- Use > quote blocks for important notes
+- Keep paragraphs short and scannable
+
+Screenshot guidance:
+- Suggest specific screenshots for each major step
+- Describe what should be visible in each screenshot
+- Example: "Screenshot showing the input form with 'bagel' entered in search field"
+- Mention UI elements to highlight (buttons, fields, tabs)
+
+Actor-specific details:
+- Use actual field names from your Actor's input schema
+- Reference specific features from your README
+- Include real example inputs that work well
+- Mention any enrichment features or add-ons
+- Explain pricing tier differences if relevant
+- Link to Actor documentation for deep dives
+
+SEO optimization:
+- Use "how to [achieve outcome]" in title and 3-5 times in content
+- Include "[Actor name] tutorial", "[Actor name] guide"
+- Use problem-related keywords (what your Actor solves)
+- Mention "Apify" 3-5 times naturally
+
+dev.to-specific elements:
+- Suggest 4 tags (e.g., #tutorial, #automation, #webscraping, #api)
+- Write a compelling first paragraph for feed preview
+- Include a discussion prompt at end: "What are you planning to scrape? Drop a comment! 💬"
+- Suggest a cover image concept (your Actor in action or logo)
+- Add liquid tag suggestions if relevant ({% link %}, {% github %})
+
+Please generate the complete tutorial now in markdown format, based on the Actor's README, with clear steps that walk users through the entire process from accessing the Actor to downloading results.`;

src/utils/github-readme-prompt.js

@@ -0,0 +1,28 @@
+export const GITHUB_README_PROMPT = `Create a comprehensive README.md for my Actor's GitHub example repository.
+
+Actor details:
+- Name: [YOUR ACTOR NAME]
+- Purpose: [WHAT IT DOES]
+- Main use cases: [LIST 3-5 USE CASES]
+- Apify Store link: [URL]
+
+README structure:
+1. Project title with badges (build status, version, etc.)
+2. Short description (1-2 sentences)
+3. Key features (bullet points)
+4. Quick start guide
+5. Installation/Setup
+6. Usage examples (3-5 code snippets)
+7. Use cases section
+8. Configuration options
+9. Common questions/troubleshooting
+10. Links (Apify Store, documentation, support)
+11. Contributing guidelines
+12. License
+
+Style:
+- Clear and scannable
+- Include code blocks with syntax highlighting
+- Add emojis for sections where appropriate
+- Professional but friendly tone
+- Emphasize ease of use`;

src/utils/hashnode-article-prompt.js

@@ -0,0 +1,95 @@
+export const HASHNODE_ARTICLE_PROMPT = `Create a comprehensive "Best [CATEGORY]" roundup article optimized for Hashnode that naturally promotes [YOUR PRODUCT/SERVICE] while providing genuine technical value to developers.
+
+Article requirements:
+- Title: "Best [CATEGORY] for [SPECIFIC USE CASE]: A Developer's Guide [YEAR]" (technical angle)
+- Word count: 1,500-2,000 words (Hashnode readers appreciate depth but value clarity)
+- Include 6-8 solutions total
+- Feature [YOUR PRODUCT/SERVICE] as position #1
+- Clear, technical but accessible tone
+- Include pros/cons for each solution
+- Add detailed comparison table
+- Include architecture/workflow diagrams suggestions where relevant
+
+Your product details:
+- Product name: [YOUR ACTOR NAME]
+- Product URL: [YOUR APIFY STORE URL]
+- Technical architecture: [HOW IT WORKS]
+- Key features: [LIST 3-5 TECHNICAL FEATURES]
+- Integration options: [APIs, SDKs, etc.]
+- Main use cases: [PROBLEMS IT SOLVES]
+- Readme content: [PASTE HERE YOUR README]
+
+Content Structure:
+1. Clear, technical introduction (150-200 words):
+   - The specific problem/challenge
+   - Why it matters to developers
+   - What criteria you used for evaluation
+   - What readers will learn
+
+2. "Understanding [CATEGORY]" - brief technical context if needed (100-150 words)
+
+3. "Evaluation criteria" - what developers should consider (150 words):
+   - Technical capabilities
+   - Performance & scalability
+   - Developer experience
+   - Documentation & support
+   - Pricing & value
+
+4. Detailed tool analysis (250-300 words each):
+   - Overview and core functionality
+   - Technical approach/architecture (briefly)
+   - Key features with technical details
+   - Strengths (3-4 items with specifics)
+   - Limitations (2-3 honest cons)
+   - Ideal use cases
+   - Getting started complexity
+   - Integration examples or code snippet (where relevant)
+   - Pricing structure
+
+5. Comprehensive comparison table - include technical specs
+
+6. "Decision framework" - help readers choose based on their needs (200-250 words)
+
+7. Conclusion with key takeaways and next steps (100-150 words)
+
+Writing guidelines:
+- Write with technical authority but remain accessible
+- Be thoroughly objective and fair to all solutions
+- Show genuine strengths of each tool with specific examples
+- For [YOUR PRODUCT], emphasize technical innovation and practical benefits
+- Include real-world scenarios and use cases
+- Use clear code blocks with proper language specification
+- Use H2 (##) and H3 (###) markdown headers consistently
+- Break up text with relevant visual suggestions (architecture diagrams, workflow charts)
+- Keep paragraphs focused and well-structured
+
+Technical depth:
+- Discuss technical implementation approaches
+- Mention performance characteristics where relevant
+- Compare API design or interface quality
+- Reference documentation quality and completeness
+- Discuss scalability and limitations honestly
+- Include actual examples from experience where possible
+
+SEO optimization:
+- Use target keyword "[CATEGORY]" 10-12 times naturally
+- Include long-tail variations like "best [category] for [use case]"
+- Add semantic technical keywords related to your domain
+- Use keywords strategically in headers
+- Include alternative phrasing that developers might search for
+
+Hashnode-specific elements:
+- Suggest 5-6 relevant tags for Hashnode (technical and general)
+- Write a compelling subtitle/brief description (under 160 characters)
+- Suggest a cover image concept (technical/professional)
+- Include a "TL;DR" section at the top after the intro (3-4 bullet points)
+- Add a "What's your experience?" prompt at the end to encourage discussion
+- Mention if this could be part of a series (e.g., "This is part 1 of my [CATEGORY] series")
+
+Code examples:
+- Include at least 1-2 code snippets showing integration or usage
+- Use proper markdown code blocks with language specification
+- Keep code examples practical and copy-pasteable
+- Add comments in code to explain key parts
+
+Please generate the complete article now in clean markdown format with proper structure.`;