Community Spotlight & How to Contribute

Community Spotlight & How to Contribute¶

This post is part of our ongoing series on network automation best practices, grounded in the PRIME Framework and PRIME Philosophy.

Transparency Note

Examples, scenarios, and any outcome figures in this article are provided for education and are based on enterprise delivery experience or anonymised composite scenarios unless explicitly identified as direct Nautomation Prime client outcomes.

Why This Blog Exists¶

Nautomation Prime is built by and for the community. This post explains how you can get involved, share your story, and help others on their automation journey.

Ways to Contribute¶

Share your success story: Submit a case study, lesson learned, or automation win. Inspire others and get featured! We're looking for stories about network transformation, cost savings, team empowerment, and lessons learned from failures.
Contribute real-world scripts: Share production-grade automation tools, templates, or frameworks you've built. Include documentation, examples, and test coverage. We'll integrate and credit you.
Write technical deep-dives: Author tutorials, walkthroughs, or technical guides on topics like:
- Device-specific automation (IOS-XE, NX-OS, Junos, Arista)
- Framework deep-dives (Nornir advanced patterns, Ansible role design, PyATS testbed strategies)
- Integration patterns (ITSM, monitoring, observability)
- Vendor-specific APIs and models
Suggest a topic: Request a blog post, tutorial, or deep dive on something you want to learn or teach. Tell us what knowledge gap exists in the community and we'll prioritize creating content to fill it.

Code & Documentation¶

Contribute code: Submit scripts, tools, bug fixes, or improvements via GitHub. See our contribution guidelines below. Examples include:
- New Nornir plugins or inventory integrations
- PyATS test libraries and compliance checkers
- Ansible roles for network automation workflows
- Utility libraries for credential management, logging, or observability
- CI/CD pipeline templates and GitHub Actions workflows
Review and improve docs: Help make our guides clearer, more accurate, and more useful for everyone. Fix typos, clarify confusing sections, add examples, or improve organization.
Create examples and demos: Build working code samples that demonstrate best practices covered in our tutorials or framework stages.

Community & Mentorship¶

Join discussions: Comment on posts, join our forums or chat, and help answer questions from others. Share your perspective, lessons learned, and working solutions.
Mentor and support: Help onboard new contributors, review pull requests, or run a community workshop. We have webinar slots and event opportunities for experienced automation engineers.
Translate and localize: Help localize our content for non-English-speaking communities (docs, blog posts, tutorials).
Maintain reference implementations: Adopt an example project or reference tool and keep it current with library updates and best practices.

How to Get Started: Step-by-Step¶

Option 1: Submit a Blog Post or Story¶

Email or open a discussion: Reach out with your idea (topic, scope, estimated length)
Coordinate with the team: We'll discuss target audience, format, and timeline
Write your draft: Use our blog post template for consistency
Feedback and iteration: Our editorial team provides feedback and works with you to refine
Publish and promote: Your post goes live with full credit and byline. We'll share it across our channels.

Timeline: Typically 2-4 weeks from initial discussion to publication.

Option 2: Contribute Code on GitHub¶

Fork our repository: Head to https://github.com/Nautomation-Prime
Check open issues: Look for issues marked good-first-issue, help-wanted, or tasks aligned with your interests
Create a feature branch: git checkout -b feature/your-feature-name
Develop and test: Write your code with tests and documentation (see code standards below)
Submit a PR: Include a clear description, screenshots if applicable, and reference any related issues
Code review: Our maintainers will review, provide feedback, and help you land the change
Merge and celebrate: Your contribution is merged and credited in the release notes

PR Tips: - Start small—fix one issue, implement one feature - Reference issues or discussions in your PR description - Include examples and tests for all new functionality - Update docs and README if adding new features - Be open to feedback and iteration

Option 3: Participate in Discussions & Forums¶

Join our community forums or Slack channel
Introduce yourself: Share your background, interests, and what brought you to Nautomation Prime
Ask questions and share solutions: Help others troubleshoot, share your experiences
Participate in threads: Comment on blog posts, provide feedback, suggest improvements
Build relationships: Connect with other automation engineers, mentors, and potential collaborators

Blog Post Template¶

Use this template to maintain consistency across contributed content:

---
title: Your Post Title Here
date: YYYY-MM-DD (date submitted)
draft: false
author: "Your Name"
description: 1-2 sentence summary of the post
tags:
  - Blog
  - [Your Tags]
  - PRIME Framework
  - Best Practices
---

## Your Post Title Here

---

> **This post is part of our ongoing series on network automation best practices, grounded in the [PRIME Framework](../../prime-framework/index.md) and [PRIME Philosophy](../../prime-framework/philosophy.md).**

## Why This Blog Exists

- 1-2 paragraphs explaining the motivation and relevance

<!-- more -->

---

## Main Content Section 1

- Use H2 for main sections
- Use H3 for subsections
- Include code examples for technical posts
- Include diagrams for visual concepts

---

## Real-World Example or Case Study

- Concrete scenario demonstrating the content
- Include code samples, screenshots, or logs

---

## PRIME in Action: [Relevant Stage]

- How does your topic align with PRIME principles?
- What stage(s) does it touch?

---

## Summary: Blog Takeaways

- 3-5 bullet points summarizing key lessons

---

## Related Tutorials & Deep Dives

- [Link to related content](../../related-file.md)
- [Another related tutorial](../../tutorials/path/to/tutorial.md)

---

## 📣 Want More?

- [Link suggesting next steps](related-post.md)
- [Link to framework overview](../../prime-framework/index.md)

---

Contribution Guidelines (Best Practices)¶

Code Standards¶

Python: Follow PEP 8, use type hints, aim for 80%+ test coverage
- Use tools: black for formatting, flake8 for linting, pytest for testing
- Example: pytest tests/ --cov=src --cov-report=html
Documentation: Clear docstrings, inline comments for complex logic, README with examples
Testing: Unit tests, integration tests, mock device tests. Write tests before code (TDD preferred)
Git hygiene: Meaningful commit messages, one feature per branch, rebase before PR
License: All contributions must align with our license (typically Apache 2.0 or MIT)

Documentation Standards¶

Write in clear, concise English
Use headers to organize content (H1 for title, H2 for sections, H3 for subsections)
Include code examples with syntax highlighting
Include diagrams for complex topics (ASCII art or Mermaid)
Provide links to related documentation and resources
Maintain consistency with existing docs (tone, terminology, structure)

Commit Message Format¶

[Category] Short description (50 chars max)

Longer explanation (if needed), wrapped at 72 characters.
Include motivation and context.

Fixes #123
Relates to #456

Categories: feat, fix, docs, test, refactor, chore, style

Pull Request Process¶

Write a clear PR description:
What does this PR do?
Why is it needed?
How can reviewers test it?
Any breaking changes?
Include evidence:
Screenshots, logs, or test results
Before/after comparisons
Performance metrics if applicable
Link to issues:
"Fixes #123" or "Relates to #456"
This auto-links issues and tracks progress
Be responsive:
Respond to feedback within 48 hours
Iterate and update your PR as needed
Appreciate reviewer suggestions

Code Standards in Detail¶

Python Example: Well-Structured Contribution¶

#!/usr/bin/env python3
"""
Module: network_discovery

Discover network topology using CDP or LLDP.
Includes error handling, logging, and test coverage.

Example:
    >>> from network_discovery import CDPDiscovery
    >>> cdp = CDPDiscovery(hosts=['10.0.0.1'], creds={'username': 'admin'})
    >>> neighbors = cdp.discover()
    >>> print(neighbors)
"""

import logging
from typing import List, Dict, Optional
from dataclasses import dataclass

logger = logging.getLogger(__name__)

@dataclass
class Neighbor:
    """Represents a discovered network neighbor."""
    device: str
    interface: str
    remote_device: str
    remote_interface: str

class CDPDiscovery:
    """Discover neighbors using CDP protocol."""

    def __init__(self, hosts: List[str], creds: Dict[str, str], timeout: int = 10):
        """
        Initialize discovery.

        Args:
            hosts: List of device IPs to query
            creds: Credentials dict with 'username' and 'password'
            timeout: Connection timeout in seconds
        """
        self.hosts = hosts
        self.creds = creds
        self.timeout = timeout

    def discover(self) -> List[Neighbor]:
        """
        Discover neighbors using CDP.

        Returns:
            List of Neighbor objects

        Raises:
            ConnectionError: If device is unreachable
            ParsingError: If CDP output cannot be parsed
        """
        neighbors = []
        for host in self.hosts:
            try:
                device_neighbors = self._query_device(host)
                neighbors.extend(device_neighbors)
                logger.info(f"Discovered {len(device_neighbors)} neighbors on {host}")
            except Exception as e:
                logger.error(f"Failed to query {host}: {e}", exc_info=True)
                raise
        return neighbors

    def _query_device(self, host: str) -> List[Neighbor]:
        """Query a single device for neighbors."""
        # Implementation details...
        pass

# Tests (tests/test_network_discovery.py)
import pytest
from unittest.mock import Mock, patch

def test_cdp_discovery_init():
    """Test CDPDiscovery initialization."""
    discovery = CDPDiscovery(['10.0.0.1'], {'username': 'admin'})
    assert discovery.hosts == ['10.0.0.1']
    assert discovery.timeout == 10

@pytest.mark.parametrize("host,expected_neighbors", [
    ('10.0.0.1', 2),
    ('10.0.0.2', 1),
])
def test_discover_multiple_hosts(host, expected_neighbors):
    """Test discovering neighbors from multiple hosts."""
    # Test with mocked device responses
    pass

Community Recognition & Rewards¶

Contributor Recognition¶

Featured in blog posts: Highlighted contributors get a blog spotlight ("Community Spotlight: [Name]")
Credits in releases: Named in release notes and CONTRIBUTORS.md
Swag and badges: Contributors earn community badges and are eligible for Nautomation Prime swag
Speaking opportunities: Exceptional contributors are invited to present at webinars or meetups
Mentor role: Long-term contributors can become maintainers or mentors

Recognition Tiers¶

Tier	Criteria	Benefits
Contributor	1+ merged PR or +100 lines of contribution	Credit, badge, mention in release notes
Active Contributor	5+ merged PRs or 5+ blog posts	All above + swag, speaking opportunity
Maintainer	Long-term, consistent contributions (6+ months)	All above + merge permissions, feature ownership

Community Spotlight: Success Stories¶

Have you automated something cool? Solved a tricky problem? Share your story and inspire others!

How to Submit Your Story¶

Email us: enquiries@nautomationprime.io with subject "Community Spotlight: [Your Story Title]"
Open a discussion: Start a thread on our GitHub Discussions channel
Submit a PR: Create a new markdown file in docs/community-spotlights/ with your story
Reach out directly: Comment on related blog posts or join our Slack channel to tell us your idea

Featured Stories We're Looking For¶

"How I Automated X in a Weekend" — Quick wins, clever scripts, or rapid deployments
"Lessons from My Worst Automation Failure" — Learning from mistakes, recovery playbooks
"Building Automation in [Industry]" — Vertical-specific challenges and solutions (services, healthcare, finance, etc.)
"How We Scaled from 50 to 500 Devices" — Growth stories, lessons on scaling
"Vendor Migration: How We Escaped Lock-In" — Migration strategies, lessons learned
"Team Transformation Through Automation" — HR impact, team empowerment stories
"Meeting Compliance Through Automation" — Compliance wins, audit stories

Recent Community Features¶

"One Engineer, 1000 Switches, 3 Months: A Nornir Journey" — by Jane Doe
"Automating Away a 12-Hour Manual Task" — by Alex Johnson
"How PyATS Saved Our Compliance Audit" — by Sam Lee
More stories at Nautomation Prime Community Blog

Frequently Asked Questions¶

I don't know much Python or coding—can I still contribute?

Absolutely! We welcome contributions at all skill levels: - Write docs or blog posts — You don't need to code - Report bugs — Found an issue? File a bug report with details - Suggest ideas — Tell us what's missing or what you'd like to learn - Help others — Answer questions in forums or chat - Translate content — Localize docs for non-English communities

How long does it take to get a PR merged?

Typically 5–10 business days: - Initial review within 48 hours - Feedback and iteration during the week - Merge once approved and CI/CD passes - Complex PRs may take longer; we'll communicate timeline upfront

Can I contribute a tool or script that uses a vendor-specific API?

Yes! We welcome vendor-specific tools as long as: - The code is well-documented and tested - It follows our code standards (PEP 8, type hints, test coverage) - It's licensed under Apache 2.0 or MIT - It's open-source (no proprietary libraries) - It includes clear setup and usage instructions - It includes examples and edge-case handling

What if my contribution gets rejected or heavily modified?

That's normal! Code review and feedback help make automation better. We appreciate your work and will: - Explain the reasoning clearly - Suggest alternative approaches - Help you iterate and improve - Credit you regardless of the final form

Can I contribute anonymously?

We prefer to credit contributors by name (it's great for your portfolio!), but we can discuss anonymity on a case-by-case basis. Reach out via email to discuss.

How do I become a maintainer?

We look for: - Consistent contributions over 6+ months - Deep knowledge of project(s) - Active participation in code reviews - Strong communication and mentorship skills - Agreement to our maintainer responsibilities (detailed in MAINTAINERS.md) Reach out to the team if you're interested in stepping into this role.

Resources for Contributors¶

GitHub: https://github.com/Nautomation-Prime
Community Discussions: GitHub Discussions channel for questions and ideas
Code of Conduct: We maintain a welcoming, inclusive environment. See CODE_OF_CONDUCT.md
Issues & Roadmap: See our Issues and Roadmap for priority areas
Developer Guide: See CONTRIBUTING.md in each repository for contribution workflow

PRIME in Action: Empowerment, Ownership, and Transparency¶

Every contribution is credited and celebrated
We believe in open knowledge and shared success
The community drives the direction of our content and tools
All contributions are reviewed for quality and impact

Summary: Blog Takeaways¶

Nautomation Prime is a community-driven project
Your contributions make the ecosystem stronger
Everyone can contribute—no matter your background or experience
PRIME principles guide everything we do—together

Deep Dive: CDP Network Audit — See how community contributions improve real-world tools.
Deep Dive: Access Switch Audit — Learn how open-source collaboration drives innovation.

Community Spotlight & How to Contribute