Developing Custom Modules and Plugins

Last updated: January 12, 2026

📚 Reference: This guide aligns with the official Developing modules and Developing plugins documentation.

My Journey into Extending Ansible

After using Ansible for several years, I hit a wall: I needed to automate a proprietary API that had no existing Ansible module. I could have cobbled together shell scripts, but I knew Ansible was capable of more. That's when I learned to develop custom modules. Later, I discovered the power of plugins to extend Ansible's core functionality. This journey transformed me from an Ansible user to an Ansible developer.

Why Develop Custom Modules and Plugins?

While Ansible ships with thousands of modules and plugins, you may encounter scenarios where custom development makes sense:

When to Create a Custom Module

• Interact with proprietary systems or APIs

• Encapsulate complex logic into reusable components

• Improve performance over shell/command modules

• Ensure idempotence for specific operations

• Provide better error handling and reporting

When to Create a Custom Plugin

• Extend Ansible's core functionality

• Create custom filters for data transformation

• Implement specialized connection methods

• Build custom inventory sources

• Add application-specific callbacks

Understanding the Difference: Modules vs Plugins

Modules

• Execute on managed nodes (remote systems)

• Perform specific tasks (install package, create user, etc.)

• Return JSON output

• Can be called from playbooks or ad-hoc commands

• Examples: apt, yum, copy, template

Plugins

• Execute on the control node (where Ansible runs)

• Extend Ansible's core functionality

• Process data, connect to systems, display output

• Examples: Filters (to_yaml), Callbacks (timer), Connection (ssh)

Developing Custom Ansible Modules

Environment Setup

First, set up your development environment:

# Install development requirements
pip install ansible-core

# Create your project structure
mkdir -p my-ansible-project/{library,module_utils,filter_plugins,callback_plugins}
cd my-ansible-project

# Optional: Clone Ansible for reference and testing tools
git clone https://github.com/ansible/ansible.git
cd ansible
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
source hacking/env-setup

Module Structure and Best Practices

Every Ansible module follows a standard structure:

#!/usr/bin/python
# -*- coding: utf-8 -*-

# Copyright: (c) 2026, Your Name <[email protected]>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type

DOCUMENTATION = r'''
---
module: my_custom_module

short_description: Brief description of what this module does

version_added: "1.0.0"

description:
    - Longer description explaining what the module does
    - Can be multiple lines
    - Should explain the primary use cases

options:
    name:
        description:
            - Name of the resource to manage
        required: true
        type: str
    
    state:
        description:
            - Desired state of the resource
        required: false
        type: str
        choices: ['present', 'absent']
        default: 'present'
    
    api_key:
        description:
            - API key for authentication
        required: true
        type: str
        no_log: true

author:
    - Your Name (@your_github_handle)

requirements:
    - python >= 3.6
    - requests >= 2.25.0
'''

EXAMPLES = r'''
# Create a resource
- name: Create new resource
  my_custom_module:
    name: my-resource
    state: present
    api_key: "{{ vault_api_key }}"

# Remove a resource
- name: Remove resource
  my_custom_module:
    name: my-resource
    state: absent
    api_key: "{{ vault_api_key }}"
'''

RETURN = r'''
resource_id:
    description: The ID of the created/modified resource
    type: str
    returned: success
    sample: 'resource-12345'

changed:
    description: Whether the module made changes
    type: bool
    returned: always
    sample: true

message:
    description: Human-readable message about what happened
    type: str
    returned: always
    sample: 'Resource created successfully'
'''

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.common.text.converters import to_native

# Your imports here
try:
    import requests
    HAS_REQUESTS = True
except ImportError:
    HAS_REQUESTS = False


def create_resource(module, name, api_key):
    """Create a new resource"""
    # Your logic here
    result = {
        'changed': True,
        'resource_id': 'resource-12345',
        'message': f'Resource {name} created successfully'
    }
    return result


def delete_resource(module, name, api_key):
    """Delete an existing resource"""
    # Your logic here
    result = {
        'changed': True,
        'message': f'Resource {name} deleted successfully'
    }
    return result


def resource_exists(name, api_key):
    """Check if resource already exists"""
    # Your logic here
    return False


def run_module():
    # Define module arguments
    module_args = dict(
        name=dict(type='str', required=True),
        state=dict(type='str', default='present', choices=['present', 'absent']),
        api_key=dict(type='str', required=True, no_log=True)
    )

    # Seed the result dict
    result = dict(
        changed=False,
        resource_id='',
        message=''
    )

    # Create AnsibleModule object
    module = AnsibleModule(
        argument_spec=module_args,
        supports_check_mode=True
    )

    # Check for required libraries
    if not HAS_REQUESTS:
        module.fail_json(msg='The requests library is required for this module')

    # Extract parameters
    name = module.params['name']
    state = module.params['state']
    api_key = module.params['api_key']

    # Check mode - don't make actual changes
    if module.check_mode:
        exists = resource_exists(name, api_key)
        if state == 'present' and not exists:
            result['changed'] = True
        elif state == 'absent' and exists:
            result['changed'] = True
        module.exit_json(**result)

    # Execute based on desired state
    try:
        if state == 'present':
            if not resource_exists(name, api_key):
                result = create_resource(module, name, api_key)
            else:
                result['message'] = f'Resource {name} already exists'
        
        elif state == 'absent':
            if resource_exists(name, api_key):
                result = delete_resource(module, name, api_key)
            else:
                result['message'] = f'Resource {name} does not exist'
    
    except Exception as e:
        module.fail_json(msg=to_native(e), **result)

    # Success!
    module.exit_json(**result)


def main():
    run_module()


if __name__ == '__main__':
    main()

Real-World Example: Custom API Module

Here's a practical example that interacts with a REST API:

#!/usr/bin/python
# -*- coding: utf-8 -*-

from __future__ import absolute_import, division, print_function
__metaclass__ = type

DOCUMENTATION = r'''
---
module: api_resource

short_description: Manage resources via REST API

description:
    - Create, update, or delete resources via a REST API
    - Supports idempotent operations

options:
    api_url:
        description: Base URL of the API
        required: true
        type: str
    
    api_token:
        description: Authentication token
        required: true
        type: str
        no_log: true
    
    resource_name:
        description: Name of the resource
        required: true
        type: str
    
    resource_type:
        description: Type of resource to manage
        required: true
        type: str
        choices: ['database', 'server', 'network']
    
    properties:
        description: Resource properties as dictionary
        required: false
        type: dict
        default: {}
    
    state:
        description: Desired state
        required: false
        type: str
        choices: ['present', 'absent']
        default: 'present'

author:
    - Your Name (@yourhandle)
'''

EXAMPLES = r'''
- name: Create database resource
  api_resource:
    api_url: https://api.example.com/v1
    api_token: "{{ vault_token }}"
    resource_name: production-db
    resource_type: database
    properties:
      size: large
      backup: true
    state: present

- name: Delete server resource
  api_resource:
    api_url: https://api.example.com/v1
    api_token: "{{ vault_token }}"
    resource_name: old-server
    resource_type: server
    state: absent
'''

RETURN = r'''
resource:
    description: Full resource object returned from API
    type: dict
    returned: success
    sample: {
        "id": "res-123",
        "name": "production-db",
        "type": "database",
        "status": "active"
    }
'''

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.common.text.converters import to_native
from ansible.module_utils.urls import open_url
import json


class APIResourceManager:
    def __init__(self, module):
        self.module = module
        self.api_url = module.params['api_url']
        self.api_token = module.params['api_token']
        self.headers = {
            'Authorization': f'Bearer {self.api_token}',
            'Content-Type': 'application/json'
        }
    
    def _make_request(self, method, endpoint, data=None):
        """Make HTTP request to API"""
        url = f"{self.api_url.rstrip('/')}/{endpoint.lstrip('/')}"
        
        try:
            if method == 'GET':
                response = open_url(url, headers=self.headers, method=method)
            else:
                response = open_url(
                    url,
                    headers=self.headers,
                    method=method,
                    data=json.dumps(data) if data else None
                )
            
            return json.loads(response.read())
        
        except Exception as e:
            self.module.fail_json(msg=f'API request failed: {to_native(e)}')
    
    def get_resource(self, name, resource_type):
        """Get resource by name and type"""
        endpoint = f'resources/{resource_type}/{name}'
        try:
            return self._make_request('GET', endpoint)
        except:
            return None
    
    def create_resource(self, name, resource_type, properties):
        """Create new resource"""
        endpoint = f'resources/{resource_type}'
        data = {
            'name': name,
            'properties': properties
        }
        return self._make_request('POST', endpoint, data)
    
    def update_resource(self, name, resource_type, properties):
        """Update existing resource"""
        endpoint = f'resources/{resource_type}/{name}'
        data = {'properties': properties}
        return self._make_request('PUT', endpoint, data)
    
    def delete_resource(self, name, resource_type):
        """Delete resource"""
        endpoint = f'resources/{resource_type}/{name}'
        return self._make_request('DELETE', endpoint)


def run_module():
    module_args = dict(
        api_url=dict(type='str', required=True),
        api_token=dict(type='str', required=True, no_log=True),
        resource_name=dict(type='str', required=True),
        resource_type=dict(type='str', required=True, choices=['database', 'server', 'network']),
        properties=dict(type='dict', default={}),
        state=dict(type='str', default='present', choices=['present', 'absent'])
    )

    result = dict(changed=False, resource={})

    module = AnsibleModule(
        argument_spec=module_args,
        supports_check_mode=True
    )

    manager = APIResourceManager(module)
    
    name = module.params['resource_name']
    resource_type = module.params['resource_type']
    properties = module.params['properties']
    state = module.params['state']

    # Get current resource state
    existing_resource = manager.get_resource(name, resource_type)

    # Check mode
    if module.check_mode:
        if state == 'present' and not existing_resource:
            result['changed'] = True
        elif state == 'absent' and existing_resource:
            result['changed'] = True
        module.exit_json(**result)

    # Execute desired state
    try:
        if state == 'present':
            if existing_resource:
                # Check if update needed
                if existing_resource.get('properties') != properties:
                    result['resource'] = manager.update_resource(name, resource_type, properties)
                    result['changed'] = True
                else:
                    result['resource'] = existing_resource
            else:
                result['resource'] = manager.create_resource(name, resource_type, properties)
                result['changed'] = True
        
        elif state == 'absent':
            if existing_resource:
                manager.delete_resource(name, resource_type)
                result['changed'] = True
    
    except Exception as e:
        module.fail_json(msg=to_native(e), **result)

    module.exit_json(**result)


def main():
    run_module()


if __name__ == '__main__':
    main()

Testing Your Module Locally

Create an arguments file for local testing:

# Create test arguments file
cat > /tmp/args.json << 'EOF'
{
    "ANSIBLE_MODULE_ARGS": {
        "api_url": "https://api.example.com/v1",
        "api_token": "test-token-123",
        "resource_name": "test-resource",
        "resource_type": "database",
        "properties": {
            "size": "medium"
        },
        "state": "present"
    }
}
EOF

# Run module directly
python library/api_resource.py /tmp/args.json

Using Your Module in a Playbook

---
- name: Test custom module
  hosts: localhost
  
  tasks:
    - name: Create API resource
      api_resource:
        api_url: https://api.example.com/v1
        api_token: "{{ api_token }}"
        resource_name: my-database
        resource_type: database
        properties:
          size: large
          backup_enabled: true
        state: present
      register: result
    
    - name: Display result
      debug:
        var: result

Developing Custom Plugins

Plugin Types

Ansible supports several plugin types:

1. Filter Plugins - Transform data in templates

2. Test Plugins - Validate data in conditionals

3. Lookup Plugins - Retrieve data from external sources

4. Callback Plugins - Respond to events and control output

5. Connection Plugins - Connect to remote hosts

6. Inventory Plugins - Load inventory from external sources

7. Vars Plugins - Inject additional variables

8. Action Plugins - Execute logic on control node before modules run

9. Cache Plugins - Store and retrieve facts

Creating a Custom Filter Plugin

Filter plugins are the most commonly created custom plugins:

# filter_plugins/custom_filters.py
from __future__ import absolute_import, division, print_function
__metaclass__ = type

from ansible.errors import AnsibleFilterError
from ansible.module_utils.common.text.converters import to_native
import re


def extract_version(value):
    """
    Extract version number from string
    
    Example:
        {{ "app-v1.2.3-beta" | extract_version }}
        Returns: "1.2.3"
    """
    try:
        match = re.search(r'(\d+\.\d+\.\d+)', str(value))
        if match:
            return match.group(1)
        raise AnsibleFilterError(f'No version found in: {value}')
    except Exception as e:
        raise AnsibleFilterError(f'extract_version failed: {to_native(e)}')


def calculate_percentage(value, total, decimals=2):
    """
    Calculate percentage
    
    Example:
        {{ 45 | calculate_percentage(200) }}
        Returns: 22.5
    """
    try:
        value = float(value)
        total = float(total)
        
        if total == 0:
            return 0
        
        percentage = (value / total) * 100
        return round(percentage, decimals)
    except Exception as e:
        raise AnsibleFilterError(f'calculate_percentage failed: {to_native(e)}')


def format_bytes(bytes_value, unit='auto'):
    """
    Format bytes to human-readable format
    
    Example:
        {{ 1536 | format_bytes }}
        Returns: "1.5 KB"
    """
    try:
        bytes_value = float(bytes_value)
        
        units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
        
        if unit != 'auto' and unit in units:
            idx = units.index(unit)
            value = bytes_value / (1024 ** idx)
            return f"{value:.2f} {unit}"
        
        # Auto-detect best unit
        for idx, unit_name in enumerate(units):
            if bytes_value < 1024 or idx == len(units) - 1:
                return f"{bytes_value:.2f} {unit_name}"
            bytes_value /= 1024
        
    except Exception as e:
        raise AnsibleFilterError(f'format_bytes failed: {to_native(e)}')


def merge_dict_deep(dict1, dict2):
    """
    Deep merge two dictionaries
    
    Example:
        {{ dict1 | merge_dict_deep(dict2) }}
    """
    try:
        import copy
        result = copy.deepcopy(dict1)
        
        for key, value in dict2.items():
            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
                result[key] = merge_dict_deep(result[key], value)
            else:
                result[key] = value
        
        return result
    except Exception as e:
        raise AnsibleFilterError(f'merge_dict_deep failed: {to_native(e)}')


class FilterModule:
    """Custom filter plugins"""
    
    def filters(self):
        return {
            'extract_version': extract_version,
            'calculate_percentage': calculate_percentage,
            'format_bytes': format_bytes,
            'merge_dict_deep': merge_dict_deep
        }

Using Custom Filters

---
- name: Demo custom filters
  hosts: localhost
  vars:
    app_name: "myapp-v2.5.1-stable"
    disk_used: 85
    disk_total: 200
    file_size: 2048576
    
    base_config:
      server:
        port: 8080
        host: localhost
      database:
        name: mydb
    
    override_config:
      server:
        port: 9090
      database:
        pool_size: 10
  
  tasks:
    - name: Extract version from app name
      debug:
        msg: "App version: {{ app_name | extract_version }}"
    
    - name: Calculate disk usage percentage
      debug:
        msg: "Disk usage: {{ disk_used | calculate_percentage(disk_total) }}%"
    
    - name: Format file size
      debug:
        msg: "File size: {{ file_size | format_bytes }}"
    
    - name: Merge configurations
      debug:
        msg: "{{ base_config | merge_dict_deep(override_config) }}"

Creating a Custom Callback Plugin

Callback plugins control output and respond to events:

# callback_plugins/execution_timer.py
from __future__ import absolute_import, division, print_function
__metaclass__ = type

DOCUMENTATION = '''
name: execution_timer
callback_type: aggregate
short_description: Display execution time for each task
description:
    - Shows execution time for every task
    - Displays total playbook execution time
    - Highlights slow tasks
options:
  slow_task_threshold:
    description: Threshold in seconds to mark tasks as slow
    ini:
      - section: callback_execution_timer
        key: slow_task_threshold
    env:
      - name: ANSIBLE_CALLBACK_EXECUTION_TIMER_THRESHOLD
    default: 5
    type: integer
'''

from datetime import datetime
from ansible.plugins.callback import CallbackBase


class CallbackModule(CallbackBase):
    """Execution timer callback plugin"""
    
    CALLBACK_VERSION = 2.0
    CALLBACK_TYPE = 'aggregate'
    CALLBACK_NAME = 'execution_timer'
    
    def __init__(self):
        super(CallbackModule, self).__init__()
        self.task_start_times = {}
        self.playbook_start_time = None
    
    def v2_playbook_on_start(self, playbook):
        """Called when playbook starts"""
        self.playbook_start_time = datetime.now()
        self._display.display(f"Playbook started at {self.playbook_start_time}")
    
    def v2_playbook_on_task_start(self, task, is_conditional):
        """Called when task starts"""
        self.task_start_times[task._uuid] = datetime.now()
    
    def v2_runner_on_ok(self, result):
        """Called when task completes successfully"""
        self._display_task_time(result._task)
    
    def v2_runner_on_failed(self, result, ignore_errors=False):
        """Called when task fails"""
        self._display_task_time(result._task, failed=True)
    
    def v2_playbook_on_stats(self, stats):
        """Called at the end of playbook"""
        if self.playbook_start_time:
            end_time = datetime.now()
            duration = end_time - self.playbook_start_time
            self._display.display(f"\nTotal playbook execution time: {duration}")
    
    def _display_task_time(self, task, failed=False):
        """Display task execution time"""
        if task._uuid in self.task_start_times:
            start_time = self.task_start_times[task._uuid]
            duration = datetime.now() - start_time
            seconds = duration.total_seconds()
            
            threshold = self.get_option('slow_task_threshold')
            
            status = "FAILED" if failed else "OK"
            marker = "⚠️ SLOW" if seconds > threshold else ""
            
            msg = f"Task '{task.get_name()}' {status} - {seconds:.2f}s {marker}"
            self._display.display(msg)
            
            del self.task_start_times[task._uuid]

Creating a Custom Lookup Plugin

Lookup plugins retrieve data from external sources:

# lookup_plugins/vault_secret.py
from __future__ import absolute_import, division, print_function
__metaclass__ = type

DOCUMENTATION = r'''
name: vault_secret
author: Your Name
short_description: Retrieve secrets from HashiCorp Vault
description:
    - Retrieves secrets from HashiCorp Vault
    - Supports KV v2 secrets engine
options:
  vault_addr:
    description: Vault server address
    env:
      - name: VAULT_ADDR
    ini:
      - section: vault_secret_lookup
        key: vault_addr
    required: true
  vault_token:
    description: Vault authentication token
    env:
      - name: VAULT_TOKEN
    required: true
    no_log: true
'''

EXAMPLES = r'''
- name: Get database password from Vault
  debug:
    msg: "{{ lookup('vault_secret', 'secret/data/database', 'password') }}"

- name: Get multiple values
  debug:
    msg: "{{ lookup('vault_secret', 'secret/data/app', 'username', 'password') }}"
'''

RETURN = r'''
_raw:
  description: Secret value(s)
  type: list
'''

from ansible.errors import AnsibleError
from ansible.plugins.lookup import LookupBase
from ansible.utils.display import Display
import os

try:
    import requests
    HAS_REQUESTS = True
except ImportError:
    HAS_REQUESTS = False

display = Display()


class LookupModule(LookupBase):
    
    def run(self, terms, variables=None, **kwargs):
        if not HAS_REQUESTS:
            raise AnsibleError('The requests library is required for vault_secret lookup')
        
        self.set_options(var_options=variables, direct=kwargs)
        
        vault_addr = self.get_option('vault_addr') or os.getenv('VAULT_ADDR')
        vault_token = self.get_option('vault_token') or os.getenv('VAULT_TOKEN')
        
        if not vault_addr:
            raise AnsibleError('vault_addr must be set')
        if not vault_token:
            raise AnsibleError('vault_token must be set')
        
        if len(terms) < 2:
            raise AnsibleError('Usage: lookup("vault_secret", "path", "key1", ["key2", ...])')
        
        path = terms[0]
        keys = terms[1:]
        
        # Fetch secret from Vault
        url = f"{vault_addr}/v1/{path}"
        headers = {'X-Vault-Token': vault_token}
        
        try:
            response = requests.get(url, headers=headers, verify=True)
            response.raise_for_status()
            data = response.json()['data']['data']
            
            # Return requested keys
            results = []
            for key in keys:
                if key not in data:
                    raise AnsibleError(f'Key {key} not found in secret {path}')
                results.append(data[key])
            
            return results
        
        except requests.RequestException as e:
            raise AnsibleError(f'Failed to retrieve secret: {str(e)}')

Testing and Validation

Testing Modules with ansible-test

# Sanity tests
ansible-test sanity --docker --python 3.9 my_custom_module

# Unit tests
ansible-test units --docker --python 3.9 my_custom_module

# Integration tests
ansible-test integration --docker my_custom_module

Creating Unit Tests

# tests/unit/modules/test_my_custom_module.py
from __future__ import absolute_import, division, print_function
__metaclass__ = type

import pytest
from ansible.module_utils import basic
from ansible.module_utils._text import to_bytes
import json


def set_module_args(args):
    """Prepare arguments for AnsibleModule"""
    args_json = json.dumps({'ANSIBLE_MODULE_ARGS': args})
    basic._ANSIBLE_ARGS = to_bytes(args_json)


def test_module_present():
    """Test module with state=present"""
    set_module_args({
        'api_url': 'https://api.example.com',
        'api_token': 'test-token',
        'resource_name': 'test-resource',
        'resource_type': 'database',
        'state': 'present'
    })
    
    # Import after setting args
    from ansible_collections.namespace.collection.plugins.modules import api_resource
    
    with pytest.raises(SystemExit):
        api_resource.main()


def test_module_absent():
    """Test module with state=absent"""
    set_module_args({
        'api_url': 'https://api.example.com',
        'api_token': 'test-token',
        'resource_name': 'test-resource',
        'resource_type': 'database',
        'state': 'absent'
    })
    
    from ansible_collections.namespace.collection.plugins.modules import api_resource
    
    with pytest.raises(SystemExit):
        api_resource.main()

Integration Testing

# tests/integration/targets/my_custom_module/tasks/main.yml
---
- name: Test module creation
  my_custom_module:
    name: test-resource
    state: present
  register: create_result

- name: Verify creation
  assert:
    that:
      - create_result is changed
      - create_result.resource_id is defined

- name: Test idempotence
  my_custom_module:
    name: test-resource
    state: present
  register: idempotent_result

- name: Verify idempotence
  assert:
    that:
      - idempotent_result is not changed

- name: Test deletion
  my_custom_module:
    name: test-resource
    state: absent
  register: delete_result

- name: Verify deletion
  assert:
    that:
      - delete_result is changed

Packaging and Distribution

Creating a Collection

Modern Ansible development uses collections:

# Create collection structure
ansible-galaxy collection init namespace.collection_name

# Structure:
# namespace/collection_name/
# ├── docs/
# ├── galaxy.yml
# ├── plugins/
# │   ├── modules/
# │   ├── filter/
# │   ├── lookup/
# │   └── callback/
# ├── roles/
# └── tests/

Building and Publishing

# Build collection
ansible-galaxy collection build

# Install locally for testing
ansible-galaxy collection install namespace-collection_name-1.0.0.tar.gz

# Publish to Galaxy
ansible-galaxy collection publish namespace-collection_name-1.0.0.tar.gz --api-key=YOUR_KEY

Best Practices

1. Documentation - Always include DOCUMENTATION, EXAMPLES, and RETURN

2. Error Handling - Use proper exception handling and meaningful messages

3. Idempotence - Ensure modules can run multiple times safely

4. Check Mode - Support --check mode for dry runs

5. Testing - Write unit and integration tests

6. Python 3 - Use Python 3 compatibility headers

7. No Logging - Mark sensitive parameters with no_log: true

8. Type Hints - Use proper type specifications in argument_spec

9. Dependencies - Document and check for required libraries

10. Performance - Be mindful of API rate limits and performance

Conclusion

Developing custom Ansible modules and plugins opens up infinite possibilities for automation. Whether you're integrating with proprietary systems, creating specialized filters, or building custom callbacks, these skills transform you from an Ansible user to an Ansible developer.

Start small, test thoroughly, and contribute back to the community when possible!

---

Further Reading

• Official Module Development Guide

• Official Plugin Development Guide

• Module Utilities

• Ansible Collections Guide

Ready to extend Ansible with your own modules and plugins? Start building today! 🔧