CE.SDK Explained: Embedded Editor and Automation Engine in One SDK

When people first hear about CE.SDK, they usually land in one of two camps. Some think it's an embeddable editor—like a design tool you drop into your app. Others think it's a creative automation API for generating images and videos at scale. Here's the thing: it's both, and that's exactly the point.

CE.SDK is a unified creative engine with dual interfaces. At its core is a single C++ rendering engine that powers everything. You can interact with it through a visual editor (for hands-on template creation and customization) or through a headless API (for programmatic generation and automation). Both interfaces use the same rendering engine, which means what you design in the editor renders identically when you generate it via the API.
This eliminates the entire category of errors stemming from inconsistencies between platforms and SDK versions.

This architecture matters because most production workflows need both capabilities. Designers create templates visually, automation generates thousands of personalized variants programmatically, and the unified engine ensures every output matches exactly.
Whether you're building a marketing platform, e-commerce personalization system, or print-on-demand service, CE.SDK provides the infrastructure to support workflows where humans and automation each do what they do best.

A simple way to think about CE.SDK:
CE.SDK is a single creative engine with two ways to control it:

• A visual UI for humans (designers, marketers, end users)
• A headless API for systems (automation, backend services)

Both control the same engine, using the same templates, producing the same output.

In this article, we'll break down how both the editor UI and automation engine work, when to use each one (or both together), common implementation patterns, and the technical capabilities that make CE.SDK different from standalone editors or API-only automation services.

The Editor UI: Professional Creative Tools for Non-Technical Teams

The visual editor component of CE.SDK provides a complete editing environment that runs directly in your application—no external tools, no browser redirects, just a fully white-label creative platform embedded wherever you need it.

Think of it as a production-grade creative workspace with timeline controls, layer management, asset libraries, and real-time preview. It handles three primary content types: image editing (filters, adjustments, composition, graphic overlays), design editing (typography, layout, vector shapes, brand elements), and timeline-based video editing (keyframes, transitions, effects, multi-track composition). This isn't a simple image cropper or text overlay tool—it's infrastructure for professional creative work.

The template intelligence is where things get interesting for product teams. You can create templates with variables and placeholders that make certain elements editable while locking down brand-critical components. For example, a designer might create a product banner template where the headline and product image are customizable, but the logo, brand colors, and layout are locked. Role-based access controls let you define exactly what different user types can modify, which is essential when you're building tools for non-designers who need creative flexibility without brand chaos.

The editor provides WYSIWYG (what you see is what you get) editing with real-time preview, so users see exactly what they'll export. No render-and-pray workflows where the final output looks different from what you designed. The same C++ rendering engine that powers the visual preview also handles the final export, ensuring complete consistency.

From a deployment perspective, CE.SDK's editor runs across platforms: web browsers (with dedicated framework bindings for React, Angular, Vue, Svelte, and vanilla JavaScript), mobile apps (native iOS and Android SDKs, plus React Native and Flutter), and even desktop applications through Electron. You build your integration once using the SDK for your stack, and the editor adapts to your platform with consistent behavior everywhere.

Here's what a basic React integration looks like:

import CreativeEditorSDK from '@cesdk/cesdk-js';

const config = {
  license: 'YOUR_LICENSE',
  userId: 'user-123'
};

const cesdk = await CreativeEditorSDK.create('#cesdk-container', config);
await cesdk.createDesignScene();

Common Use Cases for the Editor UI

Template creation by designers: Your design team builds the master templates that become the foundation for automated generation. They define the structure, set up variables, lock brand elements, and configure what end users can customize.

End-user content customization: Your customers or internal teams personalize templates within brand guidelines. They swap images, update text, adjust colors from an approved palette, but can't break layouts or remove brand elements you've locked.

Client approval workflows: Marketing teams or agencies create campaign assets and share them for stakeholder review directly within the editor interface. Reviewers make comments, request changes, and approve final versions without file-sharing chaos.

Campaign asset production: Marketing teams create social media graphics, email headers, ad creatives, and promotional materials using brand-compliant templates. They move fast without waiting for design resources, and everything stays on-brand.

The white-label capabilities mean you can completely customize the UI to match your product's look and feel. There's no IMG.LY branding, no forced visual style—just the creative tools styled however you need them. You control the interface, the asset libraries, the export options, and the entire user experience.

The Automation Engine: Headless Rendering and API-Driven Workflows

While the visual editor handles human interaction, CE.SDK's automation engine handles programmatic generation at scale. This is the headless CreativeEngine API that runs on your servers, processes batch jobs, and integrates with your backend systems to generate creative assets without human intervention.

The architecture is built for production workloads. Server-side rendering runs with GPU acceleration on Linux servers, handling everything from single-image generation to batch jobs producing thousands of assets. You control the entire creative process through code using the Scene API (managing compositions), Block API (manipulating individual elements), Asset API (handling media resources), and Event API (tracking changes and rendering progress).

Here's how headless rendering works:

import CreativeEngine from '@cesdk/node';

const engine = await CreativeEngine.init({ license: 'YOUR_LICENSE' });
const scene = await engine.scene.loadFromURL('template.scene');

// Inject data
await engine.block.setString(textBlockId, 'text/text', 'Personalized Content');

// Render
const blob = await engine.block.export(sceneId, 'image/png');

The Node.js SDK provides the backend integration layer, letting you connect CE.SDK to your databases, CMS platforms, marketing automation tools, or any other data source that drives your creative generation. You define templates (either programmatically or by loading templates created in the visual editor), inject variable data, trigger rendering, and export in multiple formats: PNG, JPG, PDF, MP4, WebP, and more.

How the Rendering Pipeline Works

The workflow follows a straightforward pattern: template definition → data injection → server-side render → export. You start with a template (a .scene file that defines the creative structure), inject your dynamic data (product names, prices, images, video clips), trigger the rendering engine to process everything, and export the final output in your target format.

What makes this powerful is that it's the same C++ rendering engine that powers the visual editor. When a designer creates a template in the editor and saves it, that template file can be loaded directly into the automation engine for programmatic generation. There's no conversion, no translation layer, no risk of visual differences. What the designer sees in the editor preview is exactly what your automation pipeline will generate at scale.

The rendering engine runs on Linux servers with GPU support for acceleration. For teams processing high volumes, this means you can scale horizontally by adding more rendering nodes, and the GPU acceleration ensures fast processing even for complex video compositions or high-resolution print outputs. For technical details on the server-side rendering architecture, see our CE.SDK Renderer deep-dive.

Common Use Cases for the Engine API

E-commerce product visualization: Generate thousands of product banners, social media posts, or email graphics from a single template. Connect your product database, loop through inventory, inject product details into the template, and export assets automatically. One template, 10,000 unique banners overnight.

Marketing automation and personalization: Create personalized ad creatives, email headers, or social media graphics based on user data, campaign parameters, or A/B testing variants. Your marketing automation platform triggers generation, CE.SDK renders the creative, and the output goes directly into your ad platform or email system.

Print-on-demand and variable data printing: Generate print-ready PDFs with variable data for each customer order. Wedding invitations with unique names, event tickets with individual QR codes, product packaging with region-specific information—all automated from templates.

Video generation at scale: Produce personalized video campaigns where recipient names, product recommendations, or custom messages are rendered into video templates. Timeline-based video editing through the API means you can programmatically control keyframes, transitions, and effects just like you would in the visual editor.

Social media content automation: Generate A/B testing variants for social ads, create multi-format posts from a single template (square for Instagram, landscape for Facebook, vertical for Stories), or automatically produce daily social graphics from data feeds.

Here's an example of template-based batch processing for an e-commerce product catalog:

const products = await database.getProducts(); // 10,000 products

for (const product of products) {
  const scene = await engine.scene.loadFromURL('product-banner-template.scene');

  // Inject product data
  await engine.block.setString(titleBlock, 'text/text', product.name);
  await engine.block.setString(priceBlock, 'text/text', product.price);
  await engine.block.replaceContentFromURL(imageBlock, product.imageUrl);

  // Export
  const output = await engine.block.export(scene, 'image/png');
  await saveToS3(`banners/${product.id}.png`, output);
}

This pattern—load template, inject data, render, export—scales from dozens to millions of assets depending on your infrastructure. The rendering engine handles the complexity of composition, effects, typography, and multi-format export so you can focus on the data pipeline and business logic.

When to Use the Editor UI, Engine API, or Both

Choosing between the visual editor, automation engine, or both comes down to who creates content, what volume you're targeting, and whether you need human intervention in your workflow.

Use the Editor UI When:

You need non-technical users to create or customize content without developer involvement. The visual interface makes template design, content personalization, and creative iteration accessible to designers, marketers, or end customers who don't write code.

Manual approval workflows are part of your process. If stakeholders need to review and refine creative before it goes live, the editor UI provides the interface for that collaboration.

Your volume is low to medium—dozens to hundreds of assets per week where manual creation or customization is practical. An agency producing client campaign assets, a marketing team creating weekly social posts, or a design team building templates for future automation all fit this profile.

Example: An agency design team creates campaign templates for multiple clients. They use the editor UI to design layouts, set up brand guidelines, lock certain elements, and define what client teams can customize. Each template becomes the foundation for client-facing customization or future automation.

Use the Engine API When:

You need high-volume automated generation—thousands or millions of assets where manual creation isn't feasible. Your volume demands infrastructure that runs without human intervention.

Integration with backend systems drives your creative output. You're connecting to databases, CMS platforms, marketing automation tools, or data pipelines that trigger creative generation based on events, schedules, or real-time data.

Scheduled batch jobs handle your creative production. Overnight processing of product catalogs, daily social media post generation, or real-time personalization for ad campaigns all require programmatic control.

Pure automation without human touchpoints is your goal. No one's reviewing individual outputs—you trust the template and data pipeline to produce correct results at scale.

Example: An e-commerce platform with 50,000 products needs fresh promotional banners weekly. The engine API connects to the product database, loads the banner template, injects product details, and generates all 50,000 banners automatically. No human reviews individual banners—the template defines quality, and the automation delivers scale.

Use Both (Hybrid Workflow) When:

Humans design templates, and systems generate variations. This is the most common production pattern: designers create and refine templates in the visual editor, then automation uses those exact templates to generate personalized variants at scale via the API.

Template iteration happens frequently, and you need designers to update creative without developer involvement. When your design team wants to refresh a template, they update it in the editor, save it, and the automation pipeline immediately starts using the new version.

You need both manual refinement and automated scale in the same workflow. Some assets require human review and customization, while others can be fully automated. The hybrid approach supports both.

Human-in-the-loop quality control improves output. Designers create and test templates visually, then automation runs with those validated templates, reducing the risk of broken layouts or design errors at scale.

Example: A marketing platform where campaign managers design email header templates in the visual editor, set up personalization variables, and preview the result. When they're satisfied, they save the template and activate the campaign. The platform's automation engine then loads that template and generates thousands of personalized variants based on recipient data, sending each one through the email system. The designer never touches code, the automation never needs manual intervention, and both work with the same template through different interfaces.

The Key Insight

Most production workflows need both the editor UI and the engine API. The visual editor accelerates template creation and makes creative iteration accessible to non-developers. The API delivers automation scale and integration with your backend systems. And the unified rendering engine ensures that what designers create in the editor is exactly what your automation generates in production—no surprises, no conversion errors, complete consistency.

Four Common CE.SDK Implementation Patterns

When teams implement CE.SDK, they typically follow one of four architectural patterns depending on their workflow needs, user types, and volume requirements.

Pattern 1: Template Marketplace + User Customization

Architecture: Pre-built templates → End users customize via editor → Export

This pattern provides a library of ready-made templates that customers browse, select, and personalize. Think of a print shop where customers choose a wedding invitation design, update the names and date, adjust colors from approved options, and export print-ready files.

The visual editor (typically the web SDK) powers the customer-facing customization experience. Templates are designed by professionals with lockable brand elements and defined customization zones. End users get creative flexibility within guardrails—they can't break layouts, remove required elements, or use off-brand colors.

Benefits: Low-code template creation for your design team, brand-safe customization for end users, fast time-to-market for personalized products. No backend integration complexity, just a catalog of templates and a customization interface.

Example use case: An online invitation platform offers hundreds of templates for events. Customers select a design, enter their event details through the editor interface, preview the result in real-time, and export PDF files for printing or digital sharing.

Pattern 2: Design Studio + Bulk Export

Architecture: Designers create in editor → Batch export via API

This pattern supports internal creative teams who design assets in the visual editor and need to export multiple formats or variations at once. An agency creating a social media campaign might design a master composition in the editor, then use the API to batch-export square, landscape, and vertical variants for different platforms.

The visual editor handles creative work, while the engine API handles the export pipeline. Designers focus on design quality, and automation handles format conversion, resizing, and bulk processing.

Benefits: Designer productivity without forcing them into code, consistent multi-format output from a single source design, batch processing for efficiency. Great for teams that need creative control with export automation.

Example use case: A brand agency creates a campaign master design in the editor with all visual elements finalized. They trigger an export script that loads the design via the API and generates 50 variants: different formats (Instagram square, Facebook landscape, LinkedIn vertical), different messaging variants (three headline options), and different CTAs (buy now, learn more, sign up). The designer created one composition, the API produced 50 assets.

Pattern 3: Template-Based Automation

Architecture: Designer creates template once → API generates thousands of variants

This is the most common hybrid pattern in production. A designer creates a template in the visual editor, defines variables and placeholders, tests with sample data, and saves the template. The automation engine then loads that template via the API and generates thousands of personalized variants by injecting data from databases, CMS systems, or marketing platforms.

The visual editor provides the template creation and testing interface. The engine API provides the scale. The unified rendering engine ensures the automated outputs match exactly what the designer previewed.

Benefits: Scale without sacrificing design quality, designer-led template creation without requiring code skills, complete automation for generation, perfect rendering consistency. This pattern combines the creative flexibility of visual tools with the efficiency of programmatic generation.

Example use case: An e-commerce platform needs product banners for 20,000 items. A designer creates a banner template in the visual editor, sets up variables for product name, price, and image, locks the brand logo and layout, and tests with sample products. Once validated, the template is saved. The platform's automation pipeline connects to the product database, loads the template via the engine API, loops through all products, injects each product's data into the template, and exports banners to the CDN. When the designer updates the template to refresh the seasonal theme, the automation immediately starts using the new version—no code changes required.

Pattern 4: Headless Programmatic Rendering

Architecture: Fully automated, no UI → API controls everything

This pattern is pure automation with no visual editor involvement. Everything is controlled programmatically through the engine API: scene creation, block manipulation, asset management, rendering, and export. Templates might be defined in code, loaded from JSON configurations, or constructed dynamically based on data inputs.

Benefits: Complete automation, infrastructure-as-code approach, serverless deployment options, integration with data pipelines and event-driven architectures. Ideal for teams with strong engineering resources who want full programmatic control.

Example use case: A serverless function generates personalized video clips when users sign up for a service. The function receives user data (name, profile image, onboarding status), constructs a video scene programmatically using the engine API, adds user-specific elements to a base template, renders the video, and delivers it via email. No human touches the creative—it's entirely data-driven.

Choosing Your Implementation Pattern

The right pattern depends on your team skills, volume requirements, and workflow complexity:

• Pattern 1 works when your users are non-technical and need guided customization.
• Pattern 2 fits creative teams who design manually but need export efficiency.
• Pattern 3 (the hybrid approach) suits most production scenarios where designers create templates and automation generates scale.
• Pattern 4 makes sense for engineering-led teams who want complete programmatic control.

Most teams start with Pattern 3 because it balances creative flexibility with automation scale. Designers create and iterate on templates without code, automation handles generation at whatever volume you need, and the unified engine keeps everything consistent.

Common Misconceptions (and the Truth)

When evaluating CE.SDK, teams often arrive with assumptions based on other tools they've used. Here are the most common misconceptions and what's actually true.

Misconception 1: "It's just a Canva clone you can embed"

The truth: CE.SDK is infrastructure, not an end-user application. Canva is a consumer-facing design tool built for end users creating content in Canva's interface. Canva Connect offers limited embedding capabilities, but you're still working within Canva's ecosystem and visual framework.

CE.SDK provides a white-label creative engine you control completely. It's not "embedding Canva"—it's building your own creative platform with your branding, your UI, your asset libraries, and your workflows. And unlike Canva, CE.SDK includes both a visual editor and an automation engine with server-side rendering. You can design templates visually and generate millions of variants programmatically with the same rendering consistency. For a detailed comparison, see our article on CE.SDK as a Canva Connect alternative.

Misconception 2: "It's just another creative automation API"

The truth: API-only services like Bannerbear or Creatomate require you to define templates in JSON or through web interfaces, then generate outputs via API calls. You're essentially coding your templates or using a separate template editor that's disconnected from the rendering pipeline.

CE.SDK includes a full visual editor where designers create templates with real-time preview and professional creative tools. Those templates are native to the rendering engine, so there's no conversion or translation when you load them via the API for automation. Your designers aren't coding templates in JSON—they're designing them visually with the same tools they'd use in any professional creative application. The API uses those exact templates for generation, ensuring perfect consistency.

Misconception 3: "The editor and API are separate products"

The truth: They're dual interfaces to the same C++ rendering engine. When you design a template in the visual editor, you're using the rendering engine's Scene API, Block API, and Asset API through a visual interface. When you generate assets via the engine API, you're using those same APIs programmatically. The underlying rendering engine is identical.

This architecture eliminates version drift. You'll never face a situation where templates designed in the editor render differently when generated via the API. What you see in the editor preview is exactly what the API will produce—same fonts, same colors, same layout, same effects, pixel-perfect consistency.

Misconception 4: "It only works for images"

The truth: CE.SDK handles images, video, and print across the same unified engine. The timeline-based video editor supports keyframes, transitions, effects, and multi-track composition. You can create video templates in the visual editor and generate personalized video variants via the API with the same workflow you'd use for images.

For print, CE.SDK exports PDF/X with CMYK color support, bleed zones, crop marks, and other print-production requirements. Whether you're generating Instagram posts, personalized videos, or print-ready brochures, it's the same SDK with format-appropriate export options.

Misconception 5: "You need to choose between editor or API"

The truth: Most production workflows use both, and the unified architecture makes this seamless. Designers create templates in the editor where they have visual control and real-time feedback. Automation generates variants via the API where you have programmatic control and scale.

You don't choose one or the other—you choose how each user type interacts with the system. Designers use the editor, automation uses the API, and both work with the same templates through the same rendering engine. This is the hybrid workflow pattern that defines modern creative automation infrastructure.

Misconception 6: "It's web-only"

The truth: CE.SDK provides cross-platform SDKs for web (JavaScript, React, Angular, Vue, Svelte, Next.js), mobile (native iOS and Android, plus React Native and Flutter), and server (Node.js for backend rendering). You choose the SDK that matches your stack, and the rendering engine ensures consistent output across all platforms.

A template created in the React web editor will render identically when generated via the Node.js server API or customized in the iOS mobile editor. Build once, deploy everywhere, with guaranteed consistency.

A Complete Picture of CE.SDK Capabilities

Because CE.SDK is built around a single CreativeEngine, its capabilities go far beyond basic layouts or simple text-on-image editing. The same engine powers design, photo, video, mockups, templating, automation, and professional file interoperability — all exposed through both the visual editor and the automation API.

Instead of stitching together seperate tools for different creative tasks, CE.SDK acts as a unified creative foundation. This makes it possible to support a wide range of production-grade workflows without introducing inconsistencies between tools, formats, or outputs.

Design, Photo, and Video Editing in One Engine

At its core, CE.SDK brings multiple creative disciplines together inside one SDK.

For design editing, it supports layout-driven content such as social graphics, banners, ads, presentations, and marketing visuals. This includes multi-layer compositions, advanced typography, vector shapes, grouping, snapping, and precise positioning controls. Designers work with familiar concepts like layers and text boxes, while product teams can restrict or guide editing through templates.

For photo editing, CE.SDK includes a full set of image manipulation features. Images can be transformed, cropped, filtered, adjusted, masked, and layered non-destructively. This makes the SDK suitable not only for graphic design, but also for photo-heavy workflows like e-commerce visuals or product imagery.

For video, CE.SDK provides a timeline-based editor with support for trimming, splitting, transitions, animations, text and graphic overlays, and multi-track compositions. Video templates created visually can later be rendered automatically via the API, using the same structure and timing that was defined in the editor.

Audio tracks can also be included in video scenes, allowing teams to combine motion, visuals, and sound within a single creative workflow.

All of these editing capabilities are powered by the same rendering engine, which means images, videos, and designs behave consistently across platforms and export formats.

Templates, Variables, and Brand Control

Templating is a core concept in CE.SDK, not an add-on feature.

Designers can create templates with placeholders and variables that define which parts of a design are editable and which are locked. Brand-critical elements like logos, layouts, fonts, or colors can be fixed in place, while text, images, or other fields remain customizable.

This makes it possible to safely expose creative tools to non-designers, customers, or internal teams without risking off-brand results. The same template definitions are then reused by the automation engine for large-scale generation.

Because templates are native to the engine, there’s no conversion step when switching from visual editing to automated rendering. What’s defined in the editor is exactly what the API uses during generation.

Mockups and Product Visualization

CE.SDK also supports mockup-based workflows through IMG.LY’s Mockup Editor capabilities.

Mockups allow designs to be placed into realistic product scenes, such as posters, packaging, apparel, or other physical products. Artwork can be dynamically injected into mockup templates, while backgrounds, frames, and scene elements stay consistent.

These mockups can be created and configured visually, then reused for automation. For example, a single mockup template can generate hundreds or thousands of product previews by swapping the underlying design or artwork via the API.

This is commonly used in print-on-demand, merchandising, and e-commerce scenarios where realistic previews are required at scale.

Professional File Import and Existing Assets

To support real-world design workflows, CE.SDK allows teams to import existing creative files rather than starting from scratch.

Designs created in Adobe Photoshop (PSD) and Adobe InDesign (via IDML) can be imported into the editor, preserving structure such as layers, text, positioning, and grouping where possible. This makes it easier for design teams to migrate from traditional desktop tools into an embedded or automated environment.

Once imported, these designs become native CE.SDK scenes. They can be edited visually, turned into templates, or used directly in automation pipelines.

This interoperability is especially valuable for organizations with a large backlog of existing design assets that need to be reused or automated over time.

Format Support Across Image, Video, and Print

CE.SDK supports a wide range of formats across different media types.

On the input side, it handles common image, video, audio, and animation formats, allowing teams to pull assets from existing libraries or external sources.

On the output side, it supports exports such as:

Images (PNG, JPEG, WebP, and more)

Video (MP4 with modern codecs)

Print-ready PDFs, including options needed for professional printing

Because all exports are produced by the same engine, teams can rely on consistent results whether content is generated interactively in the editor or automatically on the server.

Customization, Assets, and Extensibility

CE.SDK is designed to be embedded into products, not used as a fixed application.

The editor UI can be customized to show only the tools that make sense for a given use case. Asset libraries can be connected to internal systems, DAMs, or external providers. Theming and localization options make it possible to match the editor to an existing product’s look and feel.

For more advanced use cases, CE.SDK exposes APIs that allow teams to extend behavior, integrate custom logic, or build highly tailored creative experiences on top of the core engine.

AI-Powered Creative Workflows in CE.SDK

CE.SDK natively includes AI-centric features that help speed up creative tasks and expand what’s possible in both interactive editing and automated pipelines. This isn’t some vague “AI hype” add-on — these capabilities are directly built into the editor and designed to work with the rest of the SDK’s features.
img.ly

At its core, CE.SDK offers AI Editor components that let users generate and transform creative content — images, video, text, and even audio — based on simple prompts or selections. What’s especially flexible is that these features are model-agnostic, so you can integrate with your preferred third-party models or APIs rather than being locked into one provider.
img.ly

In practical terms, AI in CE.SDK can be used for things like:

• Image and content generation directly in the editor, based on text or style prompts.
• Video and graphic creation, helping users produce engaging visual content more quickly.
• Text and audio generation, including things like auto-generated voiceovers or captions.

These AI workflows plug into the existing editor UI or can be wired into automation systems, fitting into your product’s creative experiences however you want — whether end users click a button, or your system triggers generation automatically.

One key thing is that AI doesn’t replace designer intent or the rendering engine’s consistency. Generated content becomes a first-class asset inside CE.SDK: it can be edited, templated, or automated just like any other element. That means creative outputs are still governed by your templates, layouts, and brand constraints, and are fully accessible for further editing or scaling. You can learn more about the AI Editor here

Getting Started: Choosing Your Implementation Approach

Before diving into CE.SDK implementation, evaluate your specific needs across four key dimensions.

Evaluate Your Requirements

1. Who creates templates? Are your templates designed by professional designers who need visual tools, developers who prefer code-based configuration, or end users who need guided customization? This determines whether you start with the visual editor, the engine API, or both.

2. What's your volume? Are you generating dozens of assets per week (manual creation works), thousands per day (automation is essential), or millions per month (you need serious infrastructure)? Volume drives your architecture decisions and hosting requirements.

3. Where does it run? Do you need creative tools in a web application, a mobile app, a desktop application, or server-side rendering for automation? CE.SDK's cross-platform SDKs support all these scenarios, but you'll want to start with your primary deployment target.

4. What formats do you need? Are you focused on images for web and social media, video for campaigns and personalization, print-ready PDFs for production, or a combination? This affects which features you'll prioritize and how you configure export settings.

Common Starting Points

For Product Teams: Start by exploring the editor UI to understand its capabilities firsthand. Set up a prototype with your design team, create some sample templates, test the white-label customization options, and evaluate how the editor would integrate into your product's user experience. Explore demos to get the feel of the editor.

For Engineering Teams: Start with the engine API and Node.js SDK to evaluate server-side rendering performance. Create sample templates (or use the visual editor to design them, then load them via API), test batch rendering with realistic data volumes, benchmark performance for your expected workload, and evaluate server deployment requirements (Docker containers, GPU support, scaling strategy).

For Hybrid Workflows: Begin with template design in the visual editor to get comfortable with the creative interface and template structure. Then connect to the engine API for automated generation using those templates. Test the complete cycle: design a template, save it, load it via API, inject data, render, and export. This validates the end-to-end workflow and helps you understand how designers and automation will collaborate in production.

Next Steps

Try CE.SDK to test both the visual editor and engine API with your own use cases. You'll get hands-on experience with template creation, customization, and automated generation.Start your free trial now

Explore implementation guides for your specific workflow. Our upcoming marketing automation implementation guide will walk through complete hybrid setups where designers create templates and automation generates scale.See CE.SDK docs

Review case studies to see real-world implementation patterns. Teams like Omneky, Plai, and Swiss Post have built production systems on CE.SDK across different industries and use cases, showing how the unified engine supports diverse creative workflows.See case studies here

Read the technical deep-dives if you're planning server-side rendering at scale. Our CE.SDK Renderer article covers GPU acceleration, Docker deployment, performance optimization, and infrastructure considerations for high-volume rendering.

CE.SDK: One Engine, Infinite Possibilities

CE.SDK is a unified creative engine with dual interfaces: a visual editor for hands-on template creation and customization, and a headless automation API for programmatic generation at scale. Both interfaces use the same C++ rendering engine, which means you get 100% consistency between what designers create and what automation generates.

This isn't a choice between an editor or an API—it's creative infrastructure that supports both. The visual editor makes template creation accessible to designers and non-technical users. The automation engine delivers scale through server-side rendering and backend integration. And the unified rendering architecture ensures that templates designed in the editor work identically when loaded via the API for automated generation.

The workflows this enables are where CE.SDK really shines: designers create templates with visual tools, automation generates thousands of personalized variants with code, and the output is pixel-perfect consistent. Humans do what humans do best (creative design and iteration), automation does what automation does best (scale and repetition), and the unified engine keeps everything synchronized.

Whether you're building a marketing platform, e-commerce personalization system, print-on-demand service, or video generation pipeline, CE.SDK provides the foundation. You're not patching together separate tools for editing and automation—you're building on infrastructure designed from the ground up for workflows where both matter.

To explore the editor and automation engine with your own use cases, try CE.SDK and see how the unified engine works in practice or contact our sales team to help you find the best setup.