AI Automation Platform

Written by Terrell Flautt on October 6, 2025

· 7 min · snapitagent.com

Architecture

React Frontend → API Gateway → Lambda Functions
                    ↓
            DynamoDB + S3 + SQS Queues
                    ↓
        OpenAI/Claude APIs + Webhook System

Core Challenge

Problem: Users need custom AI agents without coding.
Solution: Visual workflow builder with serverless execution engine.

Agent Execution Lambda

exports.executeAgent = async (event) => {
    const { agentId, inputs, userId } = JSON.parse(event.body);

    // Load agent configuration
    const agent = await dynamoDB.get({
        TableName: 'agents',
        Key: { id: agentId }
    }).promise();

    const workflow = agent.Item.workflow;
    let context = { ...inputs };

    // Execute workflow steps
    for (const step of workflow.steps) {
        switch (step.type) {
            case 'ai_prompt':
                context = await executeAIStep(step, context);
                break;
            case 'data_transform':
                context = await transformData(step, context);
                break;
            case 'webhook':
                context = await callWebhook(step, context);
                break;
            case 'condition':
                if (evaluateCondition(step, context)) {
                    workflow.steps = step.trueBranch;
                } else {
                    workflow.steps = step.falseBranch;
                }
                break;
        }

        // Store execution state
        await dynamoDB.put({
            TableName: 'executions',
            Item: {
                id: uuidv4(),
                agentId,
                stepId: step.id,
                context,
                timestamp: Date.now(),
                userId
            }
        }).promise();
    }

    return {
        statusCode: 200,
        body: JSON.stringify({ result: context })
    };
};

Visual Workflow Builder

// React Flow integration
function WorkflowBuilder({ agentId }) {
    const [nodes, setNodes] = useState([]);
    const [edges, setEdges] = useState([]);

    const nodeTypes = {
        aiPrompt: AIPromptNode,
        dataTransform: DataTransformNode,
        webhook: WebhookNode,
        condition: ConditionNode
    };

    const onNodesChange = useCallback(
        (changes) => setNodes((nds) => applyNodeChanges(changes, nds)),
        []
    );

    const saveWorkflow = async () => {
        const workflow = { nodes, edges };
        await fetch('/api/agents/save', {
            method: 'PUT',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ agentId, workflow })
        });
    };

    return (
        <ReactFlow
            nodes={nodes}
            edges={edges}
            onNodesChange={onNodesChange}
            nodeTypes={nodeTypes}
            fitView
        >
            <Background variant="dots" />
            <Controls />
            <MiniMap />
        </ReactFlow>
    );
}

AI Integration Layer

async function executeAIStep(step, context) {
    const { provider, model, prompt, temperature } = step.config;

    // Get API key from SSM
    const apiKey = await ssm.getParameter({
        Name: `/snapitagent/${provider}-api-key`,
        WithDecryption: true
    }).promise();

    let response;
    switch (provider) {
        case 'openai':
            response = await openai.chat.completions.create({
                model: model || 'gpt-4',
                messages: [{ role: 'user', content: interpolatePrompt(prompt, context) }],
                temperature: temperature || 0.7
            });
            context.aiResponse = response.choices[0].message.content;
            break;

        case 'claude':
            response = await anthropic.messages.create({
                model: model || 'claude-3-sonnet-20240229',
                messages: [{ role: 'user', content: interpolatePrompt(prompt, context) }],
                max_tokens: 4000
            });
            context.aiResponse = response.content[0].text;
            break;
    }

    return context;
}

SQS Queue Processing

exports.processQueue = async (event) => {
    for (const record of event.Records) {
        const { agentId, executionId, delay } = JSON.parse(record.body);

        if (delay) {
            // Delayed execution
            await new Promise(resolve => setTimeout(resolve, delay * 1000));
        }

        // Continue agent execution
        const execution = await dynamoDB.get({
            TableName: 'executions',
            Key: { id: executionId }
        }).promise();

        await continueExecution(execution.Item);
    }
};

DynamoDB Schema

agents:
- id (string) - partition key
- name (string) - agent name
- userId (string) - GSI partition key
- workflow (map) - workflow definition
- status (string) - active/inactive
- createdAt (string)

executions:
- id (string) - partition key
- agentId (string) - GSI partition key
- stepId (string) - current step
- context (map) - execution context
- timestamp (number) - GSI sort key
- userId (string)
- status (string) - running/completed/failed

templates:
- id (string) - partition key
- category (string) - GSI partition key
- template (map) - workflow template
- popularity (number) - usage count

Key Features

Template Marketplace

function TemplateMarketplace() {
    const [templates] = useTemplates();

    const categories = [
        'Content Creation',
        'Data Processing',
        'Social Media',
        'Customer Support',
        'Analytics'
    ];

    return (
        <div className="template-grid">
            {templates.map(template => (
                <TemplateCard
                    key={template.id}
                    template={template}
                    onSelect={importTemplate}
                />
            ))}
        </div>
    );
}

Real-time Monitoring

// WebSocket connection for live execution
const ws = new WebSocket('wss://api.snapitagent.com/executions');

ws.onmessage = (event) => {
    const { executionId, status, output } = JSON.parse(event.data);
    updateExecutionStatus(executionId, status, output);
};

SSM Configuration

/snapitagent/openai-api-key - OpenAI API access
/snapitagent/claude-api-key - Anthropic Claude API
/snapitagent/webhook-secret - Webhook validation
/snapitagent/jwt-secret - Authentication
/snapitagent/stripe-key - Payment processing

Scaling & Performance