Structured Blocks: AI Functions from Natural Language

TL;DR

TL;DR: Structured Blocks turns natural language commands into deployable REST endpoints — describe what you want, review the generated code, and publish it directly to the cloud.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: structuredlabs.io — verified via direct HTTP request (2026-07-20)
• Source: HN launch thread — primary source for feature claims
• License: not confirmed open-source at time of writing

What Is Structured Blocks?

Structured Blocks is a feature from Structured that lets developers create custom functions using natural language. Instead of writing boilerplate code for common tasks, you describe the transformation or logic you need — for example, “Remove HTML tags from this text” — and Blocks generates the underlying code for you.

The workflow has three stages:

1. Generate — describe a task in plain English; Blocks outputs executable code
2. Sandbox test — run the function against sample data or your own datasets to verify correctness
3. Deploy — publish the function as a REST endpoint directly to Structured Cloud

Key capabilities as described on the HN launch thread:

• Natural language to code translation — input commands like “Remove HTML tags from this text” and Blocks produces functional code
• Sandbox testing environment — safely test and refine functions with sample or real data before they go live
• Code review before deployment — you can inspect and modify the generated code before it is deployed
• One-click REST endpoint deployment — customized functions become live HTTP endpoints on Structured Cloud with no additional infrastructure work

Setup Workflow

Structured Blocks is a cloud-hosted feature. There is no self-hosted option documented at this time.

Step 1: Access the Platform

Visit app.structuredlabs.io and sign up or sign in.

Step 2: Create a Function

Navigate to the Blocks section and enter a natural language description of the function you need. Blocks generates the code in real time.

Example input:
"Remove all HTML tags from a string"

Example output:
function removeHtmlTags(input) {
  return input.replace(/<[^>]*>/g, '');
}

Step 3: Test in Sandbox

Use the built-in sandbox to run your function against test data. You can pass in sample strings, arrays, or objects depending on your function’s expected input.

Step 4: Deploy as REST Endpoint

Once you are satisfied with the output, click Deploy. Blocks provisions a public REST endpoint you can call from any application or workflow automation tool.

# Example call to a deployed Blocks endpoint
curl -X POST https://api.structuredlabs.io/blocks/[your-function-id] \
  -H "Content-Type: application/json" \
  -d '{"input": "<p>Hello world</p>"}'

Deeper Analysis

Who Is This For?

Structured Blocks targets developers building internal tooling, workflow automations, or API-backed applications who need to prototype small utility functions quickly. The natural language generation layer reduces the time spent on repetitive parsing or transformation boilerplate.

It is less suited for complex business logic or performance-critical code — generated functions are best treated as starting points that you review before deployment.

Competitive Landscape

Similar tools in this space include:

• ToolJet AI — collaborative agents that help build internal tools end-to-end
• Cursor AI — AI-first code editor with built-in generation and execution capabilities
• Continue — open-source AI code assistant platform

Structured Blocks differentiates by treating function deployment as a first-class primitive, rather than a side effect of a larger tool-building workflow.

Current Limitations

Based on the launch announcement and available documentation:

• Not confirmed as open-source — a GitHub repository was not listed on the HN thread
• No self-hosted option documented
• Pricing details are not publicly listed on the website
• No public API documentation for programmatic function management at this time

Practical Evaluation Checklist

• Can input a natural language task and receive working code: yes (per HN launch)
• Can test generated code in a sandbox environment before deploying: yes
• Can review and modify generated code before it goes live: yes
• Can deploy as a REST endpoint with a single click: yes
• Open-source codebase: unconfirmed (no GitHub repo found at time of writing)
• Self-hostable: unconfirmed

Security Notes

• Generated code is executed in Structured’s sandbox environment before deployment — do not assume sandbox execution implies production safety
• Review all generated code before deploying to production, especially for input validation and sanitization
• No third-party security audit results are publicly listed as of this writing

FAQ

Q: Does Structured Blocks require a credit card to start? A: Pricing is not publicly listed. Check the Structured website for current plans.

Q: Can I use custom code instead of natural language generation? A: Yes — the platform allows you to write and modify code directly before deployment.

Q: Is the generated code open source or proprietary? A: This is not confirmed from available sources. The HN thread does not list a GitHub repository.

Q: Can I call my deployed function from any language? A: Yes — deployed functions expose standard REST endpoints, callable from any HTTP client.

Conclusion

Structured Blocks is a focused productivity tool that sits between a code generator and a full internal platform. Its strongest pitch is the natural language to deployed REST endpoint pipeline, which reduces the steps needed to go from idea to live API.

If you want to prototype utility functions fast or give non-developers a way to build simple API endpoints without writing infrastructure code, it is worth a look. Just verify the current pricing and open-source status directly on structuredlabs.io before committing to it for a production workload.