Interior design concept generation and client presentation

Introduction

Interior designers spend enormous amounts of time on repetitive tasks: sketching initial concepts, generating multiple design variations, and assembling client presentations. A designer might spend two hours generating five concept boards, when that same output could arrive in thirty minutes if the work flowed automatically from idea to finished presentation.

The problem is deeper than just time. Each step requires manual handoff. You finish a concept in Cactus Interior AI, download the images, open them in Nsketch AI, wait for sketches to render, export those, then manually assemble everything in Preswald AI for client viewing. Each transition is a chance for mistakes, delays, and frustration.

This workflow automation eliminates those handoffs entirely. You'll submit a brief once, and within minutes receive a polished client presentation with generated concepts, refined sketches, and professional layouts. No downloads. No manual file management. No delays.

The Automated Workflow

How This Works

The workflow follows four stages: brief submission, concept generation, sketch refinement, and presentation assembly. Each stage feeds directly into the next using webhooks and API calls. We'll use Make (formerly Integromat) for this example because it handles the timing well and supports the specific API patterns these tools use.

Here's what happens when you submit a project brief:

1. A form submission triggers the workflow in Make.
2. Cactus Interior AI generates 3-5 initial design concepts based on your brief.
3. Those generated images automatically feed into Nsketch AI for architectural refinement.
4. The refined sketches flow into Preswald AI, which creates a formatted presentation ready for client sharing.

All of this happens without a single manual step.

Setting Up Your Make Workflow

Start by creating a new scenario in Make. You'll need accounts with all three tools and API keys from each. Request API access from Cactus Interior AI and Nsketch AI first; they typically grant access within 24 hours.

Your initial Make module receives the project brief:

Copy
Trigger: Webhook (HTTP POST)
Expected payload:
{
  "project_name": "Downtown Apartment Redesign",
  "room_type": "living_room",
  "style_preference": "modern_minimalist",
  "colour_palette": ["cream", "charcoal", "sage_green"],
  "budget_level": "premium",
  "notes": "Client prefers natural light and open shelving"
}

Make will wait for this POST request. Once received, the workflow springs to life.

Stage One: Concept Generation with Cactus Interior AI

The first real action module calls Cactus Interior AI's concept endpoint. You'll need your API key and the base URL for their service.

Copy
Method: POST
URL: https://api.cactus-interior.ai/v1/concepts/generate
Headers:
  Authorization: Bearer YOUR_CACTUS_API_KEY
  Content-Type: application/json
Body:
{
  "room_type": "{{1.room_type}}",
  "style": "{{1.style_preference}}",
  "colours": {{1.colour_palette}},
  "budget": "{{1.budget_level}}",
  "quantity": 4,
  "resolution": "1920x1440"
}

Note the double curly braces: {{1.room_type}}. In Make, this syntax pulls data from Module 1 (your webhook trigger). Replace YOUR_CACTUS_API_KEY with your actual key.

The Cactus API returns a response like this:

Copy{
  "request_id": "req_abc123def456",
  "concepts": [
    {
      "id": "concept_1",
      "image_url": "https://cdn.cactus-interior.ai/concepts/req_abc123def456/concept_1.jpg",
      "description": "Modern minimalist approach with floating shelving"
    },
    {
      "id": "concept_2",
      "image_url": "https://cdn.cactus-interior.ai/concepts/req_abc123def456/concept_2.jpg",
      "description": "Warm minimalist with natural wood accents"
    }
  ],
  "status": "completed"
}

Store these URLs; you'll need them in the next stage. In Make, add a Set Variable module to capture the array of image URLs:

Copy
Variable name: concept_images
Value: {{2.concepts[].image_url}}

This creates an array that can loop through multiple items.

Stage Two: Sketch Refinement with Nsketch AI

Now your generated concepts need architectural refinement. Nsketch AI will take those images and enhance them with precise line work, dimensions, and material annotations.

Set up an Iterator module in Make that loops through each concept image:

Copy
Module Type: Iterator
Array: {{variable.concept_images}}

For each iteration, you'll call Nsketch AI:

Copy
Method: POST
URL: https://api.nsketch-ai.io/v2/refine
Headers:
  Authorization: Bearer YOUR_NSKETCH_API_KEY
  Content-Type: application/json
Body:
{
  "image_url": "{{4.current_item}}",
  "refinement_level": "detailed",
  "include_dimensions": true,
  "include_materials": true,
  "style_consistency": "{{1.style_preference}}"
}

The {{4.current_item}} refers to the current image URL being processed in the Iterator loop. Nsketch AI will return:

Copy{
  "request_id": "sketch_xyz789",
  "refined_image_url": "https://cdn.nsketch-ai.io/refined/sketch_xyz789/output.jpg",
  "metadata": {
    "dimensions_detected": true,
    "materials_annotated": true,
    "estimated_processing_time": 12
  }
}

Capture these refined image URLs in another Set Variable module:

Copy
Variable name: refined_sketches
Value: {{5.refined_image_url}}

Here's the critical part: because you're inside an Iterator loop, Make automatically appends each new refined image to the refined_sketches array. After the iterator completes, you'll have all four sketches ready.

Stage Three: Presentation Assembly with Preswald AI

Preswald AI is your final piece. It takes multiple images and assembles them into a professional presentation layout. This is where clients actually see your work.

Add an HTTP module that calls Preswald AI:

Copy
Method: POST
URL: https://api.preswald-ai.com/v3/presentations/create
Headers:
  Authorization: Bearer YOUR_PRESWALD_API_KEY
  Content-Type: application/json
Body:
{
  "project_title": "{{1.project_name}}",
  "client_brief": "{{1.notes}}",
  "images": {{variable.refined_sketches}},
  "layout_type": "portfolio_grid",
  "theme": "professional_light",
  "include_descriptions": true,
  "export_format": "pdf"
}

The image array from your previous step flows directly in. Preswald AI will assemble these into a formatted PDF:

Copy{
  "presentation_id": "pres_456ghi789",
  "pdf_url": "https://cdn.preswald-ai.com/presentations/pres_456ghi789/client_presentation.pdf",
  "status": "ready",
  "download_expires_in": 86400
}

Add one final module to send this to your client or storage. A simple HTTP POST to your own backend, or a Gmail module to email the PDF directly:

Copy
Module Type: Gmail
To: {{client_email}}
Subject: {{1.project_name}} - Design Concepts
Body: Your design presentation is ready. See attached.
Attachments: {{6.pdf_url}}

Error Handling and Retries

Real workflows fail sometimes. Add error handlers in Make by right-clicking any module and selecting "Add error handler."

For API timeouts, set up a simple retry:

Copy
Error Type: Connection timeout
Action: Retry 3 times with 10-second delay

For API rate limit errors (429 status code), add a longer backoff:

Copy
Error Type: Rate limited
Action: Wait 60 seconds, then retry once

If Cactus Interior AI returns an error, you should stop the entire workflow rather than passing bad data forward. Use a Router module with a condition:

Copy
Condition: If {{2.status}} != "completed"
Path 1 (error): Send notification, stop workflow
Path 2 (success): Continue to next stage

This prevents wasted processing on failed concept generation.

The Manual Alternative

If you prefer human review at certain steps, the workflow adapts easily. After Cactus Interior AI generates concepts, instead of automatically feeding them to Nsketch AI, use a Make approval module:

Copy
Module Type: Approval
Approver email: your-email@studio.com
Content: Review {{2.concepts[]}} and approve before refinement
Timeout: 24 hours

You'll receive an email asking whether to proceed. This works well if you want editorial control over which concepts move forward, or if you want to suggest modifications before refinement begins.

Alternatively, replace the final Preswald AI step with a manual assembly step. Let the automation handle concept generation and sketching, then download the refined images and build your presentation manually in your own design software. You'd still save 60-70% of the time, but keep full control over layout and client messaging.

Pro Tips

Manage API Rate Limits Carefully

Cactus Interior AI allows 100 requests per hour on their free tier. If you're processing multiple projects daily, this matters. Each project generates 4-5 concepts, so 100 requests means roughly 20-25 projects per hour maximum. Consider upgrading to their Pro plan ($29/month) which allows 500 requests per hour, or build in delays: add a "Sleep" module between projects in Make set for 30 seconds. This prevents the workflow from submitting too many requests too quickly.

Nsketch AI and Preswald AI have more generous limits (1000+ per hour), so they're rarely the bottleneck. Still, monitor your usage through their dashboards during your first week.

Test with Dummy Data First

Before connecting real client briefs, run the workflow twice with test data. Submit a simple "modern living room, neutral colours, mid-range budget" brief. Watch each stage complete. Check the images that return. This catches API authentication issues, field mapping errors, and unexpected response formats before they waste time on real projects.

Store Everything in a Database

Make your presentations reproducible. After the final Preswald AI step, add a module that stores the request data and outputs to a database. Even a simple Google Sheet works:

Copy
Module Type: Google Sheets
Action: Add a row
Sheet: Design Projects
Columns:
  - Project Name: {{1.project_name}}
  - Submission Time: {{now}}
  - Cactus Request ID: {{2.request_id}}
  - Presentation URL: {{6.pdf_url}}

This creates an audit trail. If a client later asks "can we regenerate those concepts with different colours," you have the original request data and API IDs to resubmit.

Consider Batch Processing During Off-Hours

If you submit 10 projects at once during the morning, the workflow will execute sequentially, tying up your Make account. Instead, schedule batch submissions for evenings or weekends using Make's Scheduler module. This spreads the API load and costs across cheaper off-peak hours (some providers offer reduced rates, though these three typically don't). More importantly, it means client presentations are ready the next morning without competing for API resources.

Monitor Costs Actively

Set up weekly email summaries in Make showing API call counts. Preswald AI charges per page in the final PDF; if your average presentation is growing from 5 pages to 8 pages, your cost per project rises. Track this and adjust either your brief template (to encourage more concise requests) or your layout settings (to use denser grid layouts that require fewer pages).

Cost Breakdown

Cost Per Project: Roughly £0.06 per project in tool costs (assuming average 5-page presentations), plus variable Preswald costs for longer presentations.

If you're processing fewer than 50 projects per month, reduce costs by dropping to Cactus Interior AI Free (£0), Nsketch AI Starter (£19), Preswald AI Basic (£29), and Make Free (£0). This combination costs £48/month and works well for small studios testing the approach.