Project / Independent Product
Diagrams.Design
Designing and engineering a browser-based tool for animated diagrams
- Vue.js
- Vue Flow
- Nuxt
- Canvas 2D
- WebCodecs
The product workflow
From an idea to an animated explanation, all in one workspace.
01 / 07
Overview
Designing and engineering a browser-based tool for animated diagrams
An independent project at the intersection of frontend engineering, information visualisation and motion design.
Role: Founder, Product Designer & Frontend Engineer
Timeline: 2023 – Present
Technology: Vue.js, Nuxt, TypeScript, Vue Flow, GSAP, Canvas 2D, OffscreenCanvas, Web Workers, WebCodecs
I built Diagrams.Design to make one particular creative task simpler: turning static diagrams into animated explanations, without the complexity of traditional motion-design software.
What began as a personal frustration evolved into a browser-based design and animation tool, complete with a visual editor, sequence-based animations, custom rendering architecture and client-side video export. The project brings together several areas I enjoy working in: frontend engineering, interface design, information visualisation, browser APIs and performance optimisation.
02 / 07
The Beginning
It started with a job I didn't get.
In 2023, I came across a frontend engineering role advertised by Microsoft Clipchamp, a browser-based video editing application. What caught my attention was the technology stack. Despite having spent years working in frontend engineering, I hadn't explored this particular side of browser capabilities in much depth.
Video editing, frame capturing, rendering, video codecs and muxing opened up an entirely unfamiliar area of frontend engineering for me. I began teaching myself how these technologies worked. I even applied for the position, but without real-world experience in browser-based video processing, my application was unsuccessful. Nevertheless, the experience left me with a question that I couldn't quite put aside.
If video editing and exporting could happen entirely within a browser, what else could I build using those capabilities? Around this time, I discovered the open-source work of Alyssa X, whose experiments and projects further encouraged me to explore what was possible. I began mentally dividing the technologies into two groups: those I knew intimately and those I needed to learn.
On one side were Vue, Nuxt, TypeScript, Vue Flow and GSAP. On the other were Canvas 2D, video encoding, frame processing and muxing. The things I already knew outweighed the things I didn't. That was enough of a reason to get started.
Finding a problem worth solving
Throughout my professional life, I have been making diagrams to explain technical concepts, software architecture and relationships between ideas. Most of them were static, designed primarily for articles, documentation and presentations. A4 was often my canvas of choice.
But I ever since I learned GSAP, I had always wanted my diagrams to move. I wanted to reveal information gradually, demonstrate how components interact and communicate processes in the order in which they happen. I also wanted to publish these diagrams in formats that made sense for different digital platforms — square, portrait and landscape — rather than being confined to a traditional printed page.
Diagramming applications offered the tools I needed to construct these visuals. Motion-design applications offered the tools I needed to animate them. What I wanted was something in between. I didn't need the extensive capabilities of professional motion-design software. I simply wanted to bring my diagrams to life without having to recreate them in another application or manage complicated animation timelines. I wanted the simplicity of diagramming with just enough motion to explain an idea.
Diagrams.Design became a way to solve that creative problem while exploring an entirely new area of frontend engineering. I began building it independently, outside my full-time job, during evenings and weekends.
03 / 07
The Product
Animating ideas, not scenes.
Diagrams.Design is a browser-based application for designing, animating and exporting diagrams. It is built around a simple premise: creating an animated visual explanation shouldn't require expertise in motion design. The application brings three traditionally separate activities into a single workflow.
Design: Construct a diagram using shapes, connectors, text, icons and images. Arrange elements, customise their appearance and compose the diagram for its intended publishing format.
Animate: Assign transitions and sequence numbers to individual elements. Control the order in which information appears, including which elements animate simultaneously. There is no conventional keyframe timeline to manage.
Export: Preview the animation and export it as a video, animated GIF or static image, directly from the browser, using aspect ratios and resolutions suited to the intended publishing platform.
Replacing timeline complexity with sequence-based animation
One of the earliest product decisions was to remove the need for a conventional animation timeline. When I explain a diagram, I rarely think in seconds or keyframes. I think in sequences. What should the viewer see first? What should follow? Which elements belong together? At what point does the complete picture become meaningful? This is how I wanted the animation interface to work.
Instead of positioning individual keyframes along a timeline, users assign an animation order to each element. Elements with the same order animate simultaneously. Subsequent elements follow in sequence. The underlying animation system handles the timing and transitions. It is a small change in interaction design, but an important change in the mental model. The user concentrates on the logic of the diagram rather than the mechanics of its animation.
Designing for the destination
Different publishing platforms have different spatial requirements. A diagram designed for a landscape video may require an entirely different composition from one intended for a vertical short-form video. Rather than treating aspect ratios as an export-time consideration, Diagrams.Design makes them part of the design process. The editor provides defined canvas dimensions and action-safe guides, allowing users to compose diagrams with their intended audience and publishing medium in mind.
04 / 07
Engineering Challenges
Behind a simple workflow is a considerably more complex system. The technical challenge of Diagrams.Design goes beyond building a visual editor.
The application needs to translate interactive, editable diagrams into precisely rendered visual frames, while maintaining consistency in appearance, composition and animation across different rendering environments. Much of the engineering work has involved establishing the right boundaries between the editor, animation system, rendering engine and video encoder.
01. Building a specialised diagram editor
Vue Flow provides the foundation for the interactive editor. It handles the underlying node-based environment, which I extended with custom components, connectors, design utilities and animation controls.
Some of these capabilities include:
- Custom shapes and custom connector types.
- Alignment, distribution and arrangement utilities.
- Circular arrangement of diagram elements.
- Style copying and custom colour palettes.
- Typography and image management.
- Element-level animation transitions and sequencing.
The editor is only one consumer of the underlying diagram data. The same diagram must also be understood by the animation preview and the export renderer. This distinction eventually became central to the application's architecture.
02. A shared animation model
GSAP has been an integral part of the project since its early stages. It provides the animation capabilities for the DOM-based rendering environment, where shapes, connectors and text are represented by browser elements.
However, as the export architecture evolved, it became necessary to describe animations independently of the technology responsible for displaying them. The application now uses a shared animation definition that describes what changes, when it changes and how that change progresses. The DOM-based renderer translates those instructions into GSAP animations.
The native Canvas renderer interprets the same instructions by calculating the state of each animated element at a given timestamp. For example, if a shape is moving between two positions, the native renderer can calculate its precise position at 1.5 seconds without having to play through the preceding animation.
This allows the application to render animation frames independently of real-time playback. It also provides a common foundation for sequential animations, simultaneous transitions, connector animations and word- or character-level text animations.
03. From Vue Flow to MP4
One of the most interesting engineering challenges has been building an export engine that operates entirely within the browser. Generating a video from an animated diagram involves several distinct stages.
The saved diagram must first be interpreted as a renderable scene. Fonts, icons and other visual assets need to be prepared. Animation states must be calculated at precise timestamps, and each resulting frame needs to be rendered. Those frames are then encoded and packaged into a downloadable video file. The export architecture brings together several browser technologies:
- Canvas 2D for drawing diagram primitives.
- OffscreenCanvas and Web Workers for off-main-thread rendering where supported.
- ImageBitmap and VideoFrame for handling rendered frames.
- WebCodecs for video encoding.
- Muxing libraries for packaging encoded video into MP4 and WebM containers.
The application processes frames progressively rather than retaining an entire sequence of captured images in memory. It also supports alternative rendering and encoding paths based on browser capabilities. What makes this particularly interesting to me is that the browser is not simply the interface for a remote video processing service. It is the environment in which rendering and video generation take place.
04. Rethinking the rendering architecture
The most significant technical turning point in the project came when I had to replace DOM-based frame capture with native Canvas rendering. The original export implementation reconstructed the diagram using Vue Flow, applied its animations and captured the DOM at successive points in time. It worked. But then it didn't when diagrams became more complex and exporting them became increasingly expensive.
Every additional element could increase the complexity of each captured frame, while sequential animations could also increase the total number of frames required. I began by benchmarking the existing architecture, identifying redundant operations and optimising individual stages of the pipeline. I eliminated unnecessary image conversions, corrected duplicate frame captures, introduced bounded frame processing and experimented with alternative DOM capture implementations.
These improvements helped, but the measurements consistently pointed towards the same bottleneck: repeatedly rasterising the DOM. I began wondering whether I needed to capture the DOM at all. Vue Flow already provided the underlying diagram as structured JSON data. What if I could interpret that data and redraw the entire diagram directly onto a Canvas? Ambitious, but I had to try.
Initially, this was a small architectural experiment. I wanted to see whether the performance difference would justify pursuing it further. As the experiment progressed, the results became increasingly convincing. I eventually committed to the new rendering architecture, even though it meant changing a fundamental part of the codebase I had already invested considerable time in building.
The new renderer normalises saved diagram data into a scene representation and draws its visual elements directly using native browser APIs. Instead of repeatedly taking snapshots of a webpage, it reconstructs the visual composition at a given point in time.
The performance difference
In a controlled MP4 export benchmark, using a diagram containing approximately 50 elements at 1080p, both rendering approaches produced a video of the same duration and frame schedule.
The results were:
| Metric | DOM renderer | Native Canvas renderer |
|---|---|---|
| Export time | 69.28 seconds | 3.36 seconds |
| Video duration | 28.53 seconds | 28.53 seconds |
| Captured frames | 674 | 674 |
The native rendering approach was approximately 20 times faster in this particular benchmark.
These figures represent a specific controlled benchmark, rather than a universal performance guarantee. Export performance varies with diagram complexity, resolution, browser capabilities, hardware and encoding format. The experiment also shifted how I thought about performance optimisation. Sometimes, the most effective way to make a process faster is to reconsider whether the process needs to happen at all.
05 / 07
What I've Learned
Building Diagrams.Design has been as much an exercise in learning as it has been in software development. It has challenged some of my existing assumptions about frontend engineering, architecture and product design.
Frontend engineering extends far beyond user interfaces.
Having spent much of my career working with frontend frameworks, web applications and component libraries, I was accustomed to thinking about frontend engineering largely in terms of interfaces and their supporting architecture. Diagrams.Design introduced me to a different side of the browser.
Rendering pipelines, graphics primitives, frame scheduling, interpolation, memory management, worker communication and video encoding became part of my everyday engineering vocabulary. It gave me a greater appreciation of the browser as a computing environment, not merely a platform for displaying user interfaces.
Familiar expertise can be a bridge to unfamiliar territory.
When I started this project, I didn't know everything I would eventually need to know to finish it. But I knew enough to begin. My experience with Vue, Nuxt, TypeScript and application architecture gave me a foundation from which I could explore less familiar technologies.
As the project evolved, so did the capabilities of AI-assisted development tools. AI became both a contextual learning resource and an engineering assistant. It helped me understand unfamiliar concepts, investigate implementation alternatives and reason through problems within the context of the application I was building.
The project became an ongoing process of learning, experimenting, implementing and validating. Learning through building has always been central to my approach to frontend engineering. Diagrams.Design — although much more ambitious in scale — was a continuation of that approach.
Good architecture requires a willingness to change direction.
Replacing the original rendering engine meant reconsidering decisions I had made earlier in the project. It also meant accepting that some of the code I had invested time in writing was no longer the best foundation for the application. Rather than committing to the new architecture immediately, I treated it as an experiment.
I compared approaches, measured performance and evaluated whether the new renderer could reproduce the existing visual behaviour. The final decision emerged from the evidence. The experience reinforced the importance of experimentation before commitment, particularly when architectural changes affect an established application.
Visual correctness is engineering correctness.
In most applications, a slight difference in text wrapping or the positioning of a graphical element might be considered a minor visual defect. In a diagramming application, those differences matter.
Connectors represent relationships. Spatial arrangements communicate structure. Typography affects comprehension. Animation timing determines the order in which information is understood. Developing two different rendering implementations made these details particularly important.
Matching text layout, curves, connector markers, clipping and animation behaviour became part of establishing the correctness of the system. Building Diagrams.Design has brought my interests in visual design and software engineering closer together than any of my previous projects.
06 / 07
Where the project stands
Diagrams.Design has moved beyond its initial beta into a working product with a visual editor, sequence-based animation and browser-based export. The application supports custom icons and connectors, typography, colour palettes, uploaded images, multiple aspect ratios and several export formats. I'm continuing to develop the product, refine the editing experience and explore how animation can make diagrams more useful for explaining complex ideas.
Diagrams as a way of thinking
I have always been interested in how information can be arranged visually to improve understanding. Working on Diagrams.Design has encouraged me to explore that interest beyond the technical implementation of the application itself.
What makes a branching diagram effective? How does a linear flow communicate dependencies? When does animation improve comprehension, and when does it simply become a distraction? These questions have led me to develop a collection of articles and visual experiments exploring diagram structures, information visualisation and animated explanations. The application provides the means to create these visual representations. The educational work explores the thinking behind them.
07 / 07
Explore the Project
Diagrams.Design
Diagrams.Design is an independently designed and developed web application, initially built during evenings and weekends alongside my full-time engineering career.
It continues to evolve as both a product and an exploration of what is possible with modern browser technologies.
Tutorials and visual explanations: Explore practical examples of how diagrams can communicate sequences, relationships and complex concepts.