Polotno SDK rendering explained – client-side, self-hosted, or cloud?
Imagine you’re using an online tool to design a flyer for an event. You pick colors, add text, move images around – it looks perfect on your screen. But what happens when you need to download it, print it, or send it to someone?
That’s where rendering comes in.
Rendering is like assembling furniture – all the pieces exist in the box, but until you put them together, you can’t actually use it. In the same way, your design inside an editor is just a collection of layers, text, and images. Rendering puts everything together into a finished file – an image, PDF, or video – that’s ready to be shared, printed, or published.
Without rendering, your design only exists inside the editor – it’s not a real file yet. Whether you want to print a business card, generate thousands of social media posts, or process custom branding designs at scale, you need rendering to make those designs real.
And depending on your needs, you can render on the user’s device, on your own servers, or through a cloud service – each with its own advantages. Want to know which one is right for you? Let’s break it down.
Client-side rendering
Rendering on the user’s device (client-side rendering) means everything happens locally – the browser or app processes the design in real time and generates a final image or PDF without needing a server. This works best when the user is manually exporting a single file and expects an instant download.
Since all processing relies on the user’s computer or phone, performance depends on their hardware. A lightweight social media post or a simple flyer? No problem. But if the design is complex – say a large poster with multiple images and effects – the device might slow down or struggle to handle it smoothly.
When it works best
User-initiated downloads like a single ad, flyer, or presentation slide
Simple designs that don’t require intensive processing
Local exports where speed and convenience matter more than automation
Where it struggles
Heavy designs – large posters, detailed UI mockups, or anything with lots of elements
High-resolution outputs – exporting a 5000x5000px image or multi-page PDF
Batch rendering – quickly becomes impractical as memory and CPU limits make high-volume rendering slow and unreliable
Another major downside of client-side rendering is the lack of true automation. Deep automation is practically impossible because everything depends on the user’s device and session. You can’t run background tasks or schedule rendering when the app is closed, since browsers stop processing long-running scripts.
High-volume batch rendering is also out of reach – trying to generate hundreds or thousands of variations (like localized ads or product images) will either crash the browser or slow it down to an unusable state. There’s no way to process multi-user workflows, queue up render jobs asynchronously, or handle complex transformations like AI-based image processing. Without a backend, automation is limited to what the user's device can handle in real time, making large-scale, continuous, or resource-heavy rendering unfeasible.
So for anything beyond quick, one-off downloads, server or cloud rendering becomes a better option. It offloads the heavy lifting, ensures smoother performance, and allows for automation at scale.
Self-hosted rendering
Self-hosted rendering moves the processing from the user’s device to your own servers. Instead of relying on the browser to generate the final image or PDF, the request is sent to a backend server that runs Polotno SDK inside a headless browser (like Puppeteer or Playwright). The server processes the design, renders it, and sends the final file back to the user.
This approach gives you full control over the rendering process – you can handle larger files, automate bulk exports, and ensure consistency across devices. However, since everything runs on your infrastructure, you’re responsible for maintaining server capacity, scaling, and uptime. Setting it up isn’t instant – a basic single-server setup takes 1–2 weeks, while a fully optimized, scalable system can take 4–8 weeks or longer. At minimum, you’ll need a backend developer to integrate Polotno SDK and handle API requests, while a DevOps engineer is required to configure servers, scaling, and queueing. For high-volume workloads, a cloud engineer may be needed to optimize performance and cost efficiency.
Importantly, self-hosted rendering in Polotno SDK only supports images and PDFs – video rendering is exclusive to the cloud API.
When it works best
High-resolution exports that would slow down or crash a user’s browser
Automated workflows where designs need to be generated programmatically
Batch processing – rendering multiple variations at once, like hundreds of product images or localized ad sets
Predictable performance – ensuring output is consistent across all users and devices
Where it struggles
Infrastructure costs – a single mid-tier server ($40–$100/month) can handle thousands of renders per day, but scaling for high demand can push costs into the thousands per month
Setup complexity – managing CPU-intensive processes, memory constraints, and server scaling requires engineering effort
Latency – rendering takes anywhere from 100ms to 10s per file, with bulk jobs (e.g., 1,000+ renders) introducing noticeable wait times
No video rendering – self-hosted solutions in Polotno only support images and PDFs, meaning video generation requires a cloud-based approach
Self-hosted rendering scales well for moderate workloads but requires hands-on maintenance. For high-volume automation, video processing, or a completely hands-off approach, cloud-based rendering is the better path.
Polotno Cloud rendering
Polotno Cloud Render is a fully managed rendering API built specifically for Polotno SDK, allowing you to generate images, PDFs, and videos without managing infrastructure. Instead of processing designs on the user’s device or self-hosting a rendering pipeline, you send a request to Polotno’s cloud API, and it returns a final rendered file in the format you need. Notably, this is the only way to render videos in Polotno SDK, as self-hosted solutions only support images and PDFs.
This eliminates the complexity of setting up and maintaining servers while ensuring fast, reliable, and scalable rendering. Whether you need real-time user downloads, automated design generation, or bulk processing, Polotno Cloud Render handles it all behind the scenes.
When it works best
On-demand rendering – instantly generate images, PDFs, or videos from Polotno designs without backend overhead
High-volume automation – process thousands of renders efficiently without worrying about server scaling
Batch processing – generate multiple design variations at once for ad campaigns, e-commerce visuals, or branded templates
Seamless integration – works natively with Polotno SDK, requiring minimal setup and no server maintenance
Considerations
Predictable usage costs – pricing is based on volume: $3.99 per 10,000 images and $2.99 per 100 minutes of video, which can add up for extremely high-volume use cases
Less direct control – relies on Polotno’s infrastructure rather than an in-house solution
API response times – cloud-based processing depends on network latency and server load
Since Polotno Cloud Render is designed specifically for Polotno SDK, it’s the most efficient way to integrate scalable, high-quality rendering without infrastructure headaches. For teams looking to automate design generation, support video exports, or handle large workloads, this is the fastest and most reliable path.
Hybrid approach – combining client-side and cloud rendering
For optimal performance and scalability, many applications use a hybrid approach, leveraging client-side rendering for quick, user-initiated exports while offloading bulk processing and high-resolution outputs to the cloud. This setup ensures instant responsiveness for simple tasks like downloading a single image while maintaining the ability to scale seamlessly for automated workflows, batch rendering, and video generation. By using client-side rendering as the first layer and integrating Polotno Cloud Render for heavier tasks, applications can balance speed, efficiency, and cost-effectiveness without compromising on user experience.