The simple yet powerful combination of Markdown and Jekyll has transformed how I write and publish online. The static site generator Jekyll and Markdown’s human readable syntax offers numerous benefits for bloggers, writers, and content creators.
Markdown allows me to focus on content instead of distractions. Complex word processors and WYSIWYG editors are distracting – I lose my thought while fighting with formatting options. Markdown quickly converts simple text into HTML with minimal effort, so I can pour my energy into the core stuff, writing.
Here are the main reasons I prefer writing in Markdown and using the Jekyll framework.
Complex word processors bombard writers with myriad formatting options – fonts, styles, text effects, drop-down menus, etc. This endless parade of distractions pulls my focus away from the actual content of my writing. Instead of thinking about the ideas I want to convey, I agonize over formatting.
Markdown simplifies all this formatting complexity into a handful of simple symbols that can be easily remembered and typed. Headings use hash symbols, asterisks denote emphasis, lists use dashes or asterisks, and links are created with brackets and parentheses. Simple syntax like this allows me to pour my mental energy into the substance of my writing instead of getting mired in distractions.
Everything in Markdown is meant to be human-readable. I can write Markdown in any plain text editor without rich formatting features. This means I stay focused on crafting my content instead of dealing with distracting formatting options. Even after saving my Markdown file, I can open it in any text editor and still understand everything – the headings, lists, links, etc., are clear.
When I convert Markdown to HTML, all those simple symbols and syntax are cleanly translated into the corresponding HTML tags. But as a writer, I don’t need to know or see any of that code, allowing me to stay immersed in the written word instead of technical details.
Markdown’s simple yet powerful syntax frees me from the clutches of complicated word processors and text editors, letting me devote my full attention to the content I am crafting. I can write Markdown anywhere, in any text editor, and focus entirely on writing great content instead of tweaking formatting options.
One of the greatest benefits of Markdown is that text written in this simple syntax can be displayed and edited in countless applications. Because Markdown files are just plain text, they can be opened on any device or platform.
This portability means I can write Markdown using the tools I like most and then easily share my writing with others. I tend to write Markdown using Sublime on my Mac.
No matter where or how I create my Markdown, I know the formatted text will remain consistent. When I publish my writing to my blog built with Jekyll, the Markdown syntax is converted to clean HTML for web viewing. But the original Markdown file remains unchanged – it’s portable text that works across applications.
This portability liberates me as a writer. I’m no longer locked into one particular word processor or software. I can write when and where inspiration strikes, using the tools at hand, and be assured that others can still view the content properly.
When I share my Markdown documents with collaborators, they can easily open the text files to read or edit them. There’s no need for special software since Markdown is just formatted plaintext. And if they do prefer using a particular writing app, chances are good it supports simple import of Markdown files.
Markdown works everywhere, becoming a standard format for documenting technical specifications, software development, project notes, etc. Countless applications support Markdown input and output, from Notes apps to project management tools.
Static is the Giga Chad
When visitors load a page on my Jekyll blog, their web browser retrieves flat HTML files from the hosting server. No server-side processing is required since everything has already been compiled from Markdown. This means pages load nearly instantaneously, even under high traffic.
Jekyll-generated static websites have several major performance advantages over traditional dynamic websites:
- Faster Load Times – No server-side scripting is needed, so pages load much faster for visitors.
- More Efficient Caching (I use Cloudflare) – Web servers can aggressively cache static HTML files, improving load speed.
- Reduced Server Overhead – Static sites require less CPU and memory usage on web hosts.
- Simple Deployment – Updating a static site involves uploading new HTML files, a much easier process.
- High Scalability – Static sites can scale to millions of visitors on inexpensive or free hosting.
Not only are static sites blazingly fast, but they are also inherently more secure. Since no server-side scripts are executed, there are no vulnerabilities for hackers to exploit – common issues like SQL injections and cross-site scripting simply do not apply. Static sites are immune from most types of attacks that target dynamic websites.
A static site’s speed, scalability, and security have completely changed my approach to blogging. I know that my content published in Markdown and converted into static HTML by Jekyll will load blazing fast for readers no matter how popular my blog becomes.
Because my blog posts are stored as plain text Markdown files, my content will remain readable and (hopefully) useful for a long time.
Markdown is an open standard text format not tied to any specific software or company. This means my writing can outlive the lifecycle of Jekyll, GitHub, Cloudflare, or any other tools I use today.
Traditional blog platforms tend to push a “publish and forget” mentality. Once you hit “publish,” that content is locked away in the platform’s proprietary database and entirely dependent on the company continuing to exist and maintain backward compatibility. If that service goes out of business or changes its APIs in the future, your old content may become inaccessible.
But with Jekyll and Markdown, my blog posts are stored as plain text files that will continue to work forever. Anyone can open these text files years or even decades from now and still understand the formatted content. The open standard Markdown syntax ensures readability for a long time to come.
This means that my writing has the potential to remain useful, relevant, and accessible far into the future. If my blog workflow changes or ceases to exist, I still retain fully portable copies of all my content in plain text Markdown files. These can be migrated to new systems or publishers as needed.
Old blog posts are a valuable archive of information, ideas, and history. But for that archive to remain accessible over years or decades, the content must be stored in future-proof open formats. Proprietary databases and specific software will inevitably come and go, but plain text endures.
So by writing in Markdown and generating my blog as a static site with Jekyll, I am producing timeless content that can outlive the lifecycle of any particular tools or services. My plain text Markdown files give me freedom and portability now while ensuring my writing remains readable and useful for many years.
Future readers may access my blog in ways I can’t conceive today. But as long as Markdown endures as an open standard – which seems very likely – my content will remain portable and backward compatible, providing a glimpse into this moment in history for whoever happens upon it.
One of the greatest benefits of using Jekyll to generate my blog from Markdown files is the little stress involved in publishing. My workflow is simple and repeatable:
- Write my post in Markdown.
- Add the needed YAML front matter.
- Save the file.
jekyll buildto generate the static HTML.
- Push the new post’s Markdown file to version control.
- My host (CloudFlare Pages) automatically rebuilds the site and publishes the new post.
That’s it. The entire process takes around a few minutes. I just write my content in Markdown, generate the HTML, and push – my host handles the rest.
With Markdown and Jekyll, There are no worries about outdated plugins, theme updates going awry, or errant HTML causing visual bugs. My publishing process, from writing to live, is as simple and mechanical as pushing a button. I know my plain text Markdown and Jekyll’s templates will combine flawlessly every single time.
This stress-free and hassle-free publishing experience has radically changed my relationship with writing and blogging. Instead of dreading and anxiety around the complicated process of “putting a post live,” I now have peace of mind from a repeatable workflow I trust completely. Just write in Markdown, generate the HTML, and push – the rest happens automatically.
Markdown and Jekyll embody many of the values I hold dear as a writer: simplicity, portability, permanence, and freedom. They impose virtually no constraints on my creativity while providing the structure I need to publish my work. They have empowered me to build the blog I’ve always wanted.
The open-source nature of both Markdown and Jekyll ensures they will endure for many years to come. So my investment of time and effort into this dynamic duo now promises a reliable and long-term publishing solution for the future. I am confident my content stored in Markdown and generated by Jekyll will remain useful and accessible for as long as I continue writing.