Why I Prefer Tools Like Draw.io Over Studio Applications That Can’t Be Source Controlled

In the world of software development, design, and data science, the tools we choose can significantly impact our workflow, collaboration, and long-term productivity. One of the key factors I consider when selecting a tool is whether it integrates well with version control systems like Git. This is why I tend to favor tools like Draw.io (now known as Diagrams.net) over studio-style applications that lack source control capabilities. Let me explain why.

The Power of Source Control

Source control, or version control, is the backbone of modern software development. It allows teams to track changes, collaborate efficiently, and maintain a history of their work. Tools like Git have become indispensable because they enable:

Collaboration: Multiple people can work on the same project without overwriting each other’s changes.
History: You can revert to previous versions if something goes wrong.
Transparency: Every change is documented, making it easier to understand how a project evolved.
Automation: Integration with CI/CD pipelines for testing and deployment.

When a tool supports source control, it becomes part of this ecosystem, enabling seamless workflows and reducing friction.

Why Draw.io Fits the Bill

Draw.io is a fantastic example of a tool that aligns with the principles of source control. Here’s why:

File-Based Workflow: Draw.io saves diagrams as .drawio files, which are essentially XML files. These files are human-readable (to some extent) and can be easily version-controlled using Git. Every change to the diagram is reflected in the file, making it easy to track modifications over time.
Collaboration: Since the files are stored in a Git repository, teams can collaborate on diagrams just like they would on code. Pull requests, code reviews, and branching strategies can all be applied to diagrams.
Portability: Draw.io files can be opened and edited in any environment where the tool is available, whether it’s the desktop app, the web version, or even integrated into platforms like VS Code.
Open Standards: Draw.io uses open file formats, which means you’re not locked into a proprietary ecosystem. This is a huge advantage over tools that use opaque or binary file formats.

The Problem with Studio-Style Applications

Studio-style applications, like LM Studio (a tool for running large language models locally), often lack source control integration. While they may be powerful in their own right, they come with limitations:

Proprietary Formats: Many studio applications save their data in proprietary or binary formats that can’t be easily version-controlled. This makes it difficult to track changes or collaborate effectively.
No History: Without source control, you lose the ability to revert to previous versions or understand how your work evolved over time.
Limited Collaboration: Studio applications often rely on their own collaboration features, which may not integrate well with existing workflows. For example, LM Studio doesn’t provide a way to version-control model configurations or outputs directly.
Vendor Lock-In: Proprietary tools can lock you into their ecosystem, making it harder to switch to alternatives or integrate with other tools.

A Real-World Example: LM Studio

Let’s take LM Studio as an example. It’s a great tool for experimenting with large language models locally, but it’s not designed with source control in mind. Here’s how I might work around its limitations:

Model Files: I can store different versions of model files (e.g., .gguf) in a Git repository, but these files are often large, so I’d need to use Git LFS or keep them outside version control.
Configurations: If LM Studio allows exporting configurations (e.g., JSON or YAML files), I can version-control those.
Generated Outputs: I can save and version-control the text outputs generated by the models.
Scripts: If I write scripts to automate interactions with LM Studio, I can version-control those scripts.

While these workarounds help, they’re not as seamless as using a tool like Draw.io, where the entire workflow is inherently source-control-friendly.

The Bigger Picture

The choice between tools like Draw.io and studio applications boils down to flexibility and control. Tools that embrace open standards and integrate with version control systems empower users to:

Work in a way that aligns with modern development practices.
Collaborate more effectively with teams.
Maintain a clear history of their work.
Avoid vendor lock-in and ensure long-term accessibility of their data.

For me, these benefits far outweigh the convenience of using a studio-style application that doesn’t support source control. While studio applications may offer powerful features, their lack of integration with version control systems often makes them a poor fit for my workflow.

Conclusion

In a world where collaboration, transparency, and automation are key, tools like Draw.io shine because they embrace the principles of source control. Studio applications, while useful, often fall short in this regard. By choosing tools that integrate well with version control systems, we can build workflows that are not only more efficient but also more resilient and future-proof.

So, the next time you’re evaluating a tool, ask yourself: Can I version-control my work? If the answer is yes, you’re probably on the right track. If not, it might be worth considering alternatives that better align with your long-term goals.

Imported from rifaterdemsahin.com · 2025