
Netlify CMS – An open-source CMS for Git workflows - corny
https://www.netlifycms.org/
======
bradgessler
This will sound crazy, but I recently deployed a content management workflow
for a rails app that mounts a WebDAV drive inside of a staging rails
application that's running [http://sitepress.cc/](http://sitepress.cc/) (think
Middleman in Rails, without all the dependencies)

If the marketing team wants to edit something, they mount the content drive,
make changes using their text editor of choice, and are able to preview when
they hit Save.

After they make a bunch of changes and add whatever media an engineer copies
the changes off of the drive into a commit and deploys to production.

So far it's been working pretty well. The marketing and CS team are all able
to edit markdown copy and run it easier through their content editing
processes since it's just files. They don't need to learn or care about git.
Designers can throw images in the volume without thinking too much about it.

Engineering is happy because they control their git history and commits. When
it's time to optimize PNGs, compress assets, etc. the engineer can deal with
and deploy to product with confidence.

We also run rspecs against every single page of content to enforce SEO,
branding, etc.

Happy to answer questions or write something more detailed about it if others
are interested.

~~~
edraferi
That's pretty cool. What are the marketing folks using as a WebDAV client?

~~~
reacweb
I do it often for my website. The unix command is sshfs remotehost:remote_dir
local_dir.

How do you do it with windows 10 ?

~~~
detaro
> _The unix command is sshfs remotehost:remote_dir local_dir._

That's not WebDAV, but using SSH/SFTP. Requires extra software on windows
(either an SFTP client, or if you want the filesystem integration specifically
there is a version of sshfs for Windows)

Basic WebDAV support is integrated in Windows Explorer, and has been for ages,
but there are alternative clients (both paid and free) as well.

------
benaiah
I work on this project, and it's been a big day for us - Smashing Magazine
just released a preview of its new site[0], which uses Netlify CMS as the
admin interface. I'm happy to answer any questions about the project.

[0]: [https://next.smashingmagazine.com/2017/03/a-little-
surprise-...](https://next.smashingmagazine.com/2017/03/a-little-surprise-is-
waiting-for-you-here--meet-the-next-smashing-magazine/)

~~~
leejoramo
This is so close for what I am want. However, why are you using Liquid block
elements

    
    
        {% section %} 
    

And not something more writer friendly and MarkDown-style such as CommonMark's
container blocks

    
    
        ::: section
    

This builds on the commonly used pattern of code blocks that markdown writers
know and editing apps will hopefully eventually directly support

[http://spec.commonmark.org/0.26/#container-blocks-and-
leaf-b...](http://spec.commonmark.org/0.26/#container-blocks-and-leaf-blocks)

~~~
Ajedi32
I'm not sure where you're getting that `::: section` syntax from. It doesn't
appear anywhere in the CommonMark spec. Container blocks in Markdown are just
things like blockquotes and list items...

~~~
leejoramo
Look like you are correct.

I had thought the `::: section` syntax was a recommended approach (if not yet
part of the formal spec).

In the past, I have used various home grown solutions to this, but recently I
have been using markdown-it and the accompanying plying markdown-it-container.
On the CommonMark forums, I see that the ::: syntax is a leading contender,
but that CommonMark itself will not address extensions to basic markdown until
after the spec reaches 1.0

[https://github.com/markdown-it/markdown-it-
container](https://github.com/markdown-it/markdown-it-container)

------
laktek
Pretty interesting and this is the first time I came across the term JAMStack
(a concept I always had trouble in explaining to other developers).

Rendering content blocks in server and then further enhancing them on client-
side using a JSON API can be how most sites will be built in future
(especially, with ServiceWorkers we would be able to create more fine-grained
offline experience too).

I'm also currently working on a project on similar lines, check out the
initial blog post for more details -
[http://www.laktek.com/2016/11/29/introducing-
pragma/](http://www.laktek.com/2016/11/29/introducing-pragma/)

Edit: also loved the idea of a kanban board for edit-review-publish process.
Might steal that idea ;)

~~~
brianllamar
Consider adding your project a list of headless cms's. I am hoping to expand
the category and spread the JAM.

[https://headlesscms.org/](https://headlesscms.org/)

------
gogopuppygogo
I've been using Netlify for over a year to host static websites on custom
domains and it's been impressive to me. Their control panel and tight git
integration makes for a powerful combination. Not to mention that they also
introduced a free tier for custom domains that I'm now using for some sites.

This is exciting to see them work on. I'm disappointed to see that they aren't
focusing on designers though. Something like RespondCMS for Netlify hosting
would be a superior combo.

------
trqx
If I follow instructions in the "Try it out"[1] link and click on "Connect to
github" I end up having to giving r/w access to ALL of my github repositories.

Also, reading the Step by Step guide[2] I'd end up giving r/w access to my
public keys as well.

Now, I just wake up and maybe I missed something but documentation should make
it clearer that you either have to create a dedicated github account, or how
to manage permission in a more granular fashion.

[1] [https://www.netlifycms.org/docs/test-
drive/](https://www.netlifycms.org/docs/test-drive/)

[2] [https://www.netlify.com/blog/2016/10/27/a-step-by-step-
guide...](https://www.netlify.com/blog/2016/10/27/a-step-by-step-guide-
deploying-a-static-site-or-single-page-app/)

~~~
benaiah
Unfortunately, GitHub's API does not provide per-repo permissions, so in order
to read/write to _any_ repo, the CMS has to get permission to read/write to
_all_ of them. This is a fundamental limitation of the GitHub API [0] - we'd
love to be able to request more fine-grained permissions. This is a pretty
frequent complaint about _any_ application built with GitHub's API.

The r/w access to public keys is specific to setting up continuous deployment
from a GitHub repo to Netlify's static hosting service. You can read more
about why Netlify requests those permissions for continuous deployment here:
[https://www.netlify.com/docs/github-
permissions/](https://www.netlify.com/docs/github-permissions/).

While Netlify's continuous deployment is (obviously) the deployment strategy
we recommend, you can use the CMS for any static site, as it's totally
build/deploy agnostic. You can use the CMS to edit your content and then build
that content with Hugo and host on a VPS if you wish. You can also use Netlify
to host your content without continuous deployment - it supports updating
content with both an in-browser interface and a REST API [1].

The CMS is entirely open source, so you're free to inspect or fork the code -
you can find the repository at [https://github.com/netlify/netlify-
cms/](https://github.com/netlify/netlify-cms/)

[0]:
[https://developer.github.com/v3/oauth/#scopes](https://developer.github.com/v3/oauth/#scopes)

[1]: [https://www.netlify.com/docs/api/](https://www.netlify.com/docs/api/)

~~~
splatcollision
What about supporting github read/write deploy keys? Those can be generated
with permissions for a single repo, no?

~~~
beat
That was my first thought, too. Why _not_ do it that way?

------
thenomad
Looks very cool. Does this _only_ work with Github?

Unfortunately that renders it pretty much useless for me (and probably other
non-Github users) if so.

~~~
benaiah
Unfortunately GitHub is the only backend we've implemented so far. However, we
are planning to support multiple backends, and the CMS is already
architectured to do so.

------
polymath21
How does this compare to Contentful? I've been trying to combine their
headless CMS with Middleman but it hasn't been that easy to use, although the
experience I'm trying to create is non-standard (imagine a normal blog post
but with cards inserted throughout). Plus, the cheapest paid plan is
$249/month which is really hefty when compared to the competition. Their free
tier does give you a good amount of features though and their admin UI is the
best.

I was planning to deploy my site onto Netlify once done. Wondering if maybe
your CMS is a better alternative to Contentful and I should just combine
services.

~~~
toddmorey
Contentful is nice and since it's been around longer, it's a bit more baked.
However, there's an amazing feature of static sites that are based off of
local content (markdown and yaml files, for example): every aspect of your
site can live in git.

Treating the content like code offers the advantage of being able to easily
roll back a website to any one point in time, and I think it generally makes
collaboration between designers, coders, and content editors easier.

When developing, it's really nice to just create a new branch and work on the
content and design all at the same time.

The aim of this CMS is to hopefully offer the content editing experience of
Contentful without requiring an external dependency, while also keeping all
aspects of your site tightly integrated with your git workflow.

~~~
polymath21
But the whole point of me using Contentful is that a non-developer will have
an easy time editing content within Contentful vs. having to set up a local
way of accessing those markdown/yml files through a git repo. Or do you
somehow abstract that away?

~~~
redtuesday
Yeah, that would be nice to know, because that is one of the reasons I use
Contentful at the moment. The source is on github and triggers Travis if I
push changes, which in turn get's the content from Contentful, builds the
static site with metalsmith and uploads the site through FTP. Or if the non-
developer makes changes on Contentful this triggers Travis as well etc.

Works quite nice so far (especially since I didn't need to explain how to
optimize the images) but would prefer a open source solution.

------
steffoz
Thanks for citing DatoCMS, Netlify, appreciate it :)

Really love what these guys are trying to build: critical mass over static
websites. That's what we need.

~~~
michaelmior
+1 for DatoCMS! For simple use cases it works great and combined with Netlify
makes for a great way to deploy simple static sites. Although I must say I'm
pretty excited about Netlify CMS :)

~~~
steffoz
Thank you michael :)

------
radiospiel
sorry, what exactly does this? Assuming one is looking for a CMS, the
description on the frontpage does not tell me anything. How does it compare to
other CMSes? After "Find out more" I know now that it does something with
Github, but what exactly? (Also I now know that it has something to do with a
JAMstack, whatever that might be.)

I am looking around for a smallish CMS, but I got no idea from the
introductory pages on whether or not netlify could help me

~~~
benaiah
> sorry, what exactly does this?

It's a CMS that works on static sites. Currently it primarily supports GitHub
repos for storage, but the plan is to support other alternatives (it already
supports pluggable backends, but the GitHub backend is the only one with
significant support at this point).

> How does it compare to other CMSes?

\- It doesn't require a database - it works on static files.

\- It doesn't handle building or serving websites - just editing their
content.

\- It has a built-in editorial workflow, which allows you to manage publishing
and reviewing entries in a sophisticated manner (it uses Git repositories to
do this, currently through the GitHub API), where "publishing" means pushing
to a specific branch - you're free to build and deploy your website with any
tooling you want.

\- It supports arbitrary content types and build tools, by allowing you to
describe your content in a config file.

\- It is itself usable as a simple set of static files - its entire
functionality is implemented as a JS application, so there's no server support
required to host it beyond serving files. You can also use it as an npm module
for more complex workflows (such as adding custom extensions to the CMS).

> After "Find out more" I know now that it does something with Github, but
> what exactly?

The current primary backend for Netlify CMS is the GitHub API. This means that
it allows you to store your files in a GitHub repo, connect Netlify CMS to it,
and it will use that repo to store your changes. A build system could then
pull that repo to deploy your site. The CMS itself is entirely build and
deploy agnostic.

------
matt4077
I wish people would actually use open protocols instead of private APIs, at
least in cases where both seem to be available.

As far as I can see, the only feature this needs that only github provides is
pull requests – omitting those would still leave you with a useful CMS, and
the information could also be communicated in, for example, branch names. That
way, you could conceivably use any client you want to work on the repo.

So instead of implementing Gitlab next, why not make it work with git?

This situation reminds me of email clients and libraries, many of whom now use
private APIs of a bunch of providers instead of SMTL and IMAP.

------
rogerjin12
I work at buttercms.com and we are huge fans of Netlify and how easy they've
made hosting static websites and SPAs. This CMS looks awesome and it is clever
how it hooks into Github.

------
nodesocket
I'm looking to create a back office for a consultancy company. Typical data
like clients, users, billing, etc. It seems like Netlify CMS would allow me to
create custom collections and data types correct? So instead of pages and
posts, I'd could have clients, users, invoices, etc.

~~~
benaiah
Yes - the CMS allows you to specify custom content types using the config
(example at [0]), which can have a variety of fields. There's a variety of
built-in fields, and you can create your own as well [1].

That said, the focus of the CMS team is mostly on online publishing right now
- we're trying to make editing static sites accessible enough for everyday
users and featureful enough for large publications. I'd love to hear more
about your use case and what you were thinking about using Netlify CMS for -
you can reply here, raise an issue at [https://github.com/netlify/netlify-
cms/](https://github.com/netlify/netlify-cms/), or contact me at
ben@netlify.com if you'd like to speak privately.

[0]: [https://github.com/netlify/netlify-
cms/blob/master/example/c...](https://github.com/netlify/netlify-
cms/blob/master/example/config.yml)

[1]: [https://github.com/netlify/netlify-
cms/blob/master/docs/exte...](https://github.com/netlify/netlify-
cms/blob/master/docs/extending.md)

------
boondaburrah
I was literally gearing up to build something almost exactly like this this
week as my own hackathon project. I needed a blog and I don't wanna do static
site generation on command line. I may still do it, but dang, way to take the
wind out of my sails. :P

------
Myztiq
Seems like a neat idea, I have not yet found a good example of the output that
this generates on github.

I've used prismic.io and other such systems in the past, all wonderful. I'm
glad to see this is evolving in other ways.

~~~
benaiah
The output is very flexible - you can define entry types as collections of
"widgets", which would include stuff like a title, a cover image, a markdown
body, etc. It's designed so you can use it as a CMS for almost any static site
generator by defining how your data looks in the config - see
[https://github.com/netlify/netlify-
cms/blob/master/example/c...](https://github.com/netlify/netlify-
cms/blob/master/example/config.yml) for an example config (this is a
configuration for the in-memory, non-persistent backend which we use for
testing and demonstration).

------
NKCSS
Minor nitpick on the screencast; when clicking save, it took 4-6 seconds for
it to complete and then load another page? That's not the best way to show of
your CMS and instantly makes me fear what will happen if I have a lot of
content in there.

~~~
benaiah
Netlify CMS is a single-page app, so the delay you're seeing is the wait for
an external API to respond that the entry has saved succesfully - you wouldn't
want to leave the page only to find out that your changes weren't saved. When
using the in-memory backend (which doesn't persist changes), saving happens
with no such delay. Since the delay is almost entirely from the network and
external API, it shouldn't get worse with lots of files unless the external
API takes longer to respond. Our current primary backend is the GitHub API,
which handles lots of files without much change in response time in my
experience.

------
inthewoods
Surprised in all this that no one has mentioned www.cloudcannon.com - works
with Jekyll and allows our marketing group to make live edits on the website
while maintaining the whole thing on Github.

------
roscoebeezie
When CMS is not Conversational​ Monitor System...

------
ranyefet
Great idea, definitely going to try it out

------
therealmarv
So this does not work with gitlab, right?

~~~
benaiah
Not yet - there's an issue [0] for that in the GitHub repository [1].

[0]: [https://github.com/netlify/netlify-
cms/issues/57](https://github.com/netlify/netlify-cms/issues/57)

[1]: [https://github.com/netlify/netlify-
cms](https://github.com/netlify/netlify-cms)

------
yellowboxtenant
How does user management work?

------
m-j-fox
Dumb question: what is a CMS?

~~~
0x27081990
Content management system

