Skip to content

Design Philosophy & Vision

🎯 Our Mission

To democratize Terraform provider development by making it accessible to Python developers worldwide, enabling them to leverage their existing skills and Python's rich ecosystem to build robust infrastructure automation tools.

✨ Why Choose Pyvider?

For Python Developers

  • 🐍 Native Python Experience: Write providers using familiar Python patterns and idioms
  • 📚 Rich Ecosystem: Access thousands of Python libraries for cloud APIs, databases, and services
  • 🎓 Gentle Learning Curve: No need to learn Go or complex protocol details
  • 🧪 Familiar Testing: Use pytest and your favorite Python testing tools

For Infrastructure Teams

  • ⚡ Rapid Development: Build providers 3-5x faster than traditional Go implementations
  • 🔒 Type Safety: Leverage Python's type hints and attrs for robust, maintainable code
  • 📊 Better Observability: Built-in structured logging with provide.foundation
  • 🚀 Production Ready: Battle-tested with comprehensive error handling and state management

For Organizations

  • 💼 Lower Barrier to Entry: Tap into your existing Python talent pool
  • 🔄 Faster Iteration: Quick prototyping and development cycles
  • 🎯 Focused Development: Decorators handle protocol complexity—teams focus on business logic
  • ✅ Enterprise Ready: Full Terraform compatibility with no compromises

📊 Comparison with Traditional Providers

For Reference Only

This comparison is provided for informational purposes. As Pyvider is in alpha, we recommend evaluating based on your specific needs rather than treating this as a definitive decision matrix.

Feature Pyvider (Python) Traditional (Go)
Language Python 3.11+ Go
Learning Curve Gentle (Python devs) Steep
Development Speed Fast Moderate
Ecosystem Vast (PyPI) Growing
Type Safety Type hints + attrs Static typing
Testing pytest go test
Debugging Python debuggers delve
Performance Excellent Excellent
Protocol Support v6 (latest) v5/v6

Key Advantages of Pyvider: - Python's extensive ecosystem (100,000+ packages on PyPI) - Faster development cycles with dynamic typing and concise syntax - Lower barrier to entry for teams already using Python - Built-in structured logging and observability

When to Consider Go: - Maximum performance is critical (though Pyvider performs excellently) - Team has deep Go expertise - Need for extensive community provider ecosystem (HashiCorp's official providers)

🌟 Early Adopters & Use Cases

Pyvider is currently in alpha and being used by early adopters for:

Internal Tooling

Building custom providers for company-specific infrastructure: - Internal API management systems - Custom database provisioning - Internal service orchestration - Company-specific cloud abstractions

Rapid Prototyping

Testing provider concepts before committing to Go implementations: - Validate infrastructure patterns quickly - Proof-of-concept for new integrations - Experiment with Terraform patterns - Test feasibility of provider ideas

Python-First Teams

Leveraging existing Python expertise for IaC: - Teams with strong Python but limited Go experience - Organizations with Python-heavy tech stacks - Data engineering teams extending their Python workflows - DevOps teams comfortable with Python automation

Educational Projects

Teaching Terraform provider development concepts: - University courses on infrastructure as code - Internal training programs - Workshops and tutorials - Learning Terraform plugin protocol

Design Principles

1. Python-Native Experience

Pyvider is designed to feel natural to Python developers: - Use familiar patterns (decorators, type hints, attrs) - Leverage Python's rich standard library - Integrate seamlessly with Python tools (pytest, mypy, ruff) - Follow Pythonic conventions

2. Progressive Disclosure

Start simple, add complexity as needed: - Basic providers require minimal code - Advanced features available when needed - Sensible defaults for everything - Clear upgrade paths

3. Type Safety First

Strong typing throughout: - Full type hints on all public APIs - Runtime validation via attrs - Schema-driven data modeling - IDE autocomplete and validation

4. Observability by Default

Built-in logging and monitoring: - Structured logging via provide.foundation - Automatic request/response logging - Performance metrics - Debug-friendly error messages

5. Developer Experience

Optimize for developer productivity: - Clear error messages with actionable advice - Comprehensive documentation - Working examples for every feature - Fast feedback loops (testing, debugging)

Architecture Philosophy

Hub-Based Discovery

Components self-register via decorators: 

@register_provider("my_provider")
class MyProvider(Provider):
    """Provider registration is automatic."""
    pass

Benefits: - No manual registration boilerplate - Components are independent modules - Easy to add new components - Clear component boundaries

Decorator-Based API

Hide protocol complexity behind decorators: 

@register_resource("my_resource")
class MyResource(Resource):
    """Protocol details handled automatically."""

    async def create(self, config, state):
        # Just implement the business logic
        return {"id": "123", "name": config.name}

Benefits: - Focus on business logic, not protocol - Consistent patterns across all components - Reduced boilerplate - Easier testing

Schema-Driven Validation

Use attrs for data modeling: 

@attrs.define
class ResourceConfig:
    name: str = Attribute(required=True)
    count: int = Attribute(default=1, validators=[Range(min=1, max=10)])

Benefits: - Compile-time type checking - Runtime validation - Self-documenting schemas - IDE support

Future Vision

Pyvider aims to become:

  1. The Python Way to Build Providers
  2. First-class support in the Terraform ecosystem
  3. Comprehensive provider library in Python

  4. Industry-standard for Python-based IaC tooling

  5. A Complete Development Platform

  6. Integrated testing framework (TofuSoup)
  7. Packaging and distribution (Flavor)
  8. Documentation generation (Plating)

  9. Development environment (wrknv)

  10. A Thriving Community

  11. Shared library of components (pyvider-components)
  12. Community-contributed providers
  13. Best practices and patterns
  14. Educational resources

Contributing to the Vision

We welcome contributions that align with these principles:

  • Python-idiomatic code
  • Type-safe implementations
  • Comprehensive tests
  • Clear documentation
  • Working examples

See our Contributing Guidelines for details.

Ready to build with Pyvider? Check out the Quick Start Guide