-
Home
+
home
{% for page in site.pages %}
{% if page.layout == "page" %}
-
{{ page.title }}
+
{{ page.title }}
{% endif %}
{% endfor %}
diff --git a/_includes/script.html b/_includes/script.html
index b10f08b045..b700ff4b50 100644
--- a/_includes/script.html
+++ b/_includes/script.html
@@ -1 +1,3 @@
+
+
diff --git a/_layouts/default.html b/_layouts/default.html
index 9d3ba7a6dc..b895b5048d 100644
--- a/_layouts/default.html
+++ b/_layouts/default.html
@@ -1,5 +1,5 @@
-
+
{% include head.html %}
diff --git a/_posts/2015-02-10-hello-world.md b/_posts/2015-02-10-hello-world.md
deleted file mode 100644
index 523f0733b4..0000000000
--- a/_posts/2015-02-10-hello-world.md
+++ /dev/null
@@ -1,4 +0,0 @@
----
-title: Hello World
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Totam quasi maxime quas repudiandae nam id temporibus, at et non officiis consectetur voluptate deserunt officia minima placeat tempore illum asperiores quo assumenda praesentium? Facilis libero error ratione doloribus debitis delectus asperiores minima ab velit quam. Natus ea, vero totam recusandae autem, corporis minima, animi eos perferendis omnis ut asperiores magni tempore. Repellendus aliquam saepe perspiciatis laborum, excepturi sit libero dignissimos debitis eaque itaque quos, accusantium sed amet tempora temporibus perferendis possimus, quisquam minus fuga! Laudantium, tenetur, consectetur! Quas itaque hic consequatur accusamus consectetur, quia odio eos amet quasi pariatur! Ratione, similique.
\ No newline at end of file
diff --git a/_posts/2015-02-15-example-1.md b/_posts/2015-02-15-example-1.md
deleted file mode 100644
index 51044cfe28..0000000000
--- a/_posts/2015-02-15-example-1.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Example 1
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Cupiditate est optio ut impedit architecto iusto tempore rem, voluptates sed magni nisi corrupti praesentium voluptatum harum expedita temporibus ipsam, odit ad distinctio! Labore cupiditate distinctio facere earum, iste! Reiciendis possimus voluptatum explicabo corporis ab. Ex adipisci laudantium mollitia vel optio deserunt blanditiis cum dolore beatae facilis molestias ut a doloribus recusandae delectus, repudiandae, rerum quo eaque quaerat enim dolores perspiciatis voluptatum odio accusamus! Doloribus fuga provident, magni eaque consequatur quia incidunt similique. Nostrum animi facere mollitia, corrupti vitae, itaque maiores consequatur, explicabo, sapiente molestiae consequuntur! Aliquam hic dolorum atque dolorem repudiandae nostrum optio praesentium quisquam vero. Nostrum illum modi aut, ratione qui! Quas laudantium, soluta asperiores minima molestiae similique consequatur ut.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda ad tenetur, numquam aliquid excepturi fuga. Pariatur numquam rem possimus, optio voluptate aspernatur ex, ipsum tenetur earum molestiae nulla suscipit sequi labore fugit repudiandae natus? Nam vel rem, rerum maxime harum. Molestias suscipit quaerat molestiae dolores fuga earum modi, distinctio repellat, laborum commodi quibusdam ex dolore, eius maiores architecto necessitatibus. Repellendus a vitae, est nesciunt. Aspernatur fugiat labore cumque, optio, magni, aperiam ut totam error eligendi iure culpa illum dolorum quam?
\ No newline at end of file
diff --git a/_posts/2015-02-15-example-2.md b/_posts/2015-02-15-example-2.md
deleted file mode 100644
index 41e8268b1b..0000000000
--- a/_posts/2015-02-15-example-2.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Example 2
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Cupiditate est optio ut impedit architecto iusto tempore rem, voluptates sed magni nisi corrupti praesentium voluptatum harum expedita temporibus ipsam, odit ad distinctio! Labore cupiditate distinctio facere earum, iste! Reiciendis possimus voluptatum explicabo corporis ab. Ex adipisci laudantium mollitia vel optio deserunt blanditiis cum dolore beatae facilis molestias ut a doloribus recusandae delectus, repudiandae, rerum quo eaque quaerat enim dolores perspiciatis voluptatum odio accusamus! Doloribus fuga provident, magni eaque consequatur quia incidunt similique. Nostrum animi facere mollitia, corrupti vitae, itaque maiores consequatur, explicabo, sapiente molestiae consequuntur! Aliquam hic dolorum atque dolorem repudiandae nostrum optio praesentium quisquam vero. Nostrum illum modi aut, ratione qui! Quas laudantium, soluta asperiores minima molestiae similique consequatur ut.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda ad tenetur, numquam aliquid excepturi fuga. Pariatur numquam rem possimus, optio voluptate aspernatur ex, ipsum tenetur earum molestiae nulla suscipit sequi labore fugit repudiandae natus? Nam vel rem, rerum maxime harum. Molestias suscipit quaerat molestiae dolores fuga earum modi, distinctio repellat, laborum commodi quibusdam ex dolore, eius maiores architecto necessitatibus. Repellendus a vitae, est nesciunt. Aspernatur fugiat labore cumque, optio, magni, aperiam ut totam error eligendi iure culpa illum dolorum quam?
\ No newline at end of file
diff --git a/_posts/2015-02-15-example-3.md b/_posts/2015-02-15-example-3.md
deleted file mode 100644
index e53301322f..0000000000
--- a/_posts/2015-02-15-example-3.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Example 3
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Cupiditate est optio ut impedit architecto iusto tempore rem, voluptates sed magni nisi corrupti praesentium voluptatum harum expedita temporibus ipsam, odit ad distinctio! Labore cupiditate distinctio facere earum, iste! Reiciendis possimus voluptatum explicabo corporis ab. Ex adipisci laudantium mollitia vel optio deserunt blanditiis cum dolore beatae facilis molestias ut a doloribus recusandae delectus, repudiandae, rerum quo eaque quaerat enim dolores perspiciatis voluptatum odio accusamus! Doloribus fuga provident, magni eaque consequatur quia incidunt similique. Nostrum animi facere mollitia, corrupti vitae, itaque maiores consequatur, explicabo, sapiente molestiae consequuntur! Aliquam hic dolorum atque dolorem repudiandae nostrum optio praesentium quisquam vero. Nostrum illum modi aut, ratione qui! Quas laudantium, soluta asperiores minima molestiae similique consequatur ut.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda ad tenetur, numquam aliquid excepturi fuga. Pariatur numquam rem possimus, optio voluptate aspernatur ex, ipsum tenetur earum molestiae nulla suscipit sequi labore fugit repudiandae natus? Nam vel rem, rerum maxime harum. Molestias suscipit quaerat molestiae dolores fuga earum modi, distinctio repellat, laborum commodi quibusdam ex dolore, eius maiores architecto necessitatibus. Repellendus a vitae, est nesciunt. Aspernatur fugiat labore cumque, optio, magni, aperiam ut totam error eligendi iure culpa illum dolorum quam?
\ No newline at end of file
diff --git a/_posts/2015-02-15-example-4.md b/_posts/2015-02-15-example-4.md
deleted file mode 100644
index 4c5dfa728e..0000000000
--- a/_posts/2015-02-15-example-4.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Example 4
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Cupiditate est optio ut impedit architecto iusto tempore rem, voluptates sed magni nisi corrupti praesentium voluptatum harum expedita temporibus ipsam, odit ad distinctio! Labore cupiditate distinctio facere earum, iste! Reiciendis possimus voluptatum explicabo corporis ab. Ex adipisci laudantium mollitia vel optio deserunt blanditiis cum dolore beatae facilis molestias ut a doloribus recusandae delectus, repudiandae, rerum quo eaque quaerat enim dolores perspiciatis voluptatum odio accusamus! Doloribus fuga provident, magni eaque consequatur quia incidunt similique. Nostrum animi facere mollitia, corrupti vitae, itaque maiores consequatur, explicabo, sapiente molestiae consequuntur! Aliquam hic dolorum atque dolorem repudiandae nostrum optio praesentium quisquam vero. Nostrum illum modi aut, ratione qui! Quas laudantium, soluta asperiores minima molestiae similique consequatur ut.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda ad tenetur, numquam aliquid excepturi fuga. Pariatur numquam rem possimus, optio voluptate aspernatur ex, ipsum tenetur earum molestiae nulla suscipit sequi labore fugit repudiandae natus? Nam vel rem, rerum maxime harum. Molestias suscipit quaerat molestiae dolores fuga earum modi, distinctio repellat, laborum commodi quibusdam ex dolore, eius maiores architecto necessitatibus. Repellendus a vitae, est nesciunt. Aspernatur fugiat labore cumque, optio, magni, aperiam ut totam error eligendi iure culpa illum dolorum quam?
\ No newline at end of file
diff --git a/_posts/2015-02-15-example-5.md b/_posts/2015-02-15-example-5.md
deleted file mode 100644
index dd07181644..0000000000
--- a/_posts/2015-02-15-example-5.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Example 5
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Cupiditate est optio ut impedit architecto iusto tempore rem, voluptates sed magni nisi corrupti praesentium voluptatum harum expedita temporibus ipsam, odit ad distinctio! Labore cupiditate distinctio facere earum, iste! Reiciendis possimus voluptatum explicabo corporis ab. Ex adipisci laudantium mollitia vel optio deserunt blanditiis cum dolore beatae facilis molestias ut a doloribus recusandae delectus, repudiandae, rerum quo eaque quaerat enim dolores perspiciatis voluptatum odio accusamus! Doloribus fuga provident, magni eaque consequatur quia incidunt similique. Nostrum animi facere mollitia, corrupti vitae, itaque maiores consequatur, explicabo, sapiente molestiae consequuntur! Aliquam hic dolorum atque dolorem repudiandae nostrum optio praesentium quisquam vero. Nostrum illum modi aut, ratione qui! Quas laudantium, soluta asperiores minima molestiae similique consequatur ut.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda ad tenetur, numquam aliquid excepturi fuga. Pariatur numquam rem possimus, optio voluptate aspernatur ex, ipsum tenetur earum molestiae nulla suscipit sequi labore fugit repudiandae natus? Nam vel rem, rerum maxime harum. Molestias suscipit quaerat molestiae dolores fuga earum modi, distinctio repellat, laborum commodi quibusdam ex dolore, eius maiores architecto necessitatibus. Repellendus a vitae, est nesciunt. Aspernatur fugiat labore cumque, optio, magni, aperiam ut totam error eligendi iure culpa illum dolorum quam?
\ No newline at end of file
diff --git a/_posts/2015-02-15-example-6.md b/_posts/2015-02-15-example-6.md
deleted file mode 100644
index 38922891df..0000000000
--- a/_posts/2015-02-15-example-6.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Example 6
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Cupiditate est optio ut impedit architecto iusto tempore rem, voluptates sed magni nisi corrupti praesentium voluptatum harum expedita temporibus ipsam, odit ad distinctio! Labore cupiditate distinctio facere earum, iste! Reiciendis possimus voluptatum explicabo corporis ab. Ex adipisci laudantium mollitia vel optio deserunt blanditiis cum dolore beatae facilis molestias ut a doloribus recusandae delectus, repudiandae, rerum quo eaque quaerat enim dolores perspiciatis voluptatum odio accusamus! Doloribus fuga provident, magni eaque consequatur quia incidunt similique. Nostrum animi facere mollitia, corrupti vitae, itaque maiores consequatur, explicabo, sapiente molestiae consequuntur! Aliquam hic dolorum atque dolorem repudiandae nostrum optio praesentium quisquam vero. Nostrum illum modi aut, ratione qui! Quas laudantium, soluta asperiores minima molestiae similique consequatur ut.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda ad tenetur, numquam aliquid excepturi fuga. Pariatur numquam rem possimus, optio voluptate aspernatur ex, ipsum tenetur earum molestiae nulla suscipit sequi labore fugit repudiandae natus? Nam vel rem, rerum maxime harum. Molestias suscipit quaerat molestiae dolores fuga earum modi, distinctio repellat, laborum commodi quibusdam ex dolore, eius maiores architecto necessitatibus. Repellendus a vitae, est nesciunt. Aspernatur fugiat labore cumque, optio, magni, aperiam ut totam error eligendi iure culpa illum dolorum quam?
\ No newline at end of file
diff --git a/_posts/2015-02-15-example-7.md b/_posts/2015-02-15-example-7.md
deleted file mode 100644
index 6f48c68972..0000000000
--- a/_posts/2015-02-15-example-7.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Example 7
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Cupiditate est optio ut impedit architecto iusto tempore rem, voluptates sed magni nisi corrupti praesentium voluptatum harum expedita temporibus ipsam, odit ad distinctio! Labore cupiditate distinctio facere earum, iste! Reiciendis possimus voluptatum explicabo corporis ab. Ex adipisci laudantium mollitia vel optio deserunt blanditiis cum dolore beatae facilis molestias ut a doloribus recusandae delectus, repudiandae, rerum quo eaque quaerat enim dolores perspiciatis voluptatum odio accusamus! Doloribus fuga provident, magni eaque consequatur quia incidunt similique. Nostrum animi facere mollitia, corrupti vitae, itaque maiores consequatur, explicabo, sapiente molestiae consequuntur! Aliquam hic dolorum atque dolorem repudiandae nostrum optio praesentium quisquam vero. Nostrum illum modi aut, ratione qui! Quas laudantium, soluta asperiores minima molestiae similique consequatur ut.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda ad tenetur, numquam aliquid excepturi fuga. Pariatur numquam rem possimus, optio voluptate aspernatur ex, ipsum tenetur earum molestiae nulla suscipit sequi labore fugit repudiandae natus? Nam vel rem, rerum maxime harum. Molestias suscipit quaerat molestiae dolores fuga earum modi, distinctio repellat, laborum commodi quibusdam ex dolore, eius maiores architecto necessitatibus. Repellendus a vitae, est nesciunt. Aspernatur fugiat labore cumque, optio, magni, aperiam ut totam error eligendi iure culpa illum dolorum quam?
\ No newline at end of file
diff --git a/_posts/2015-02-15-example-8.md b/_posts/2015-02-15-example-8.md
deleted file mode 100644
index c2a1a827e1..0000000000
--- a/_posts/2015-02-15-example-8.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Example 8
----
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Cupiditate est optio ut impedit architecto iusto tempore rem, voluptates sed magni nisi corrupti praesentium voluptatum harum expedita temporibus ipsam, odit ad distinctio! Labore cupiditate distinctio facere earum, iste! Reiciendis possimus voluptatum explicabo corporis ab. Ex adipisci laudantium mollitia vel optio deserunt blanditiis cum dolore beatae facilis molestias ut a doloribus recusandae delectus, repudiandae, rerum quo eaque quaerat enim dolores perspiciatis voluptatum odio accusamus! Doloribus fuga provident, magni eaque consequatur quia incidunt similique. Nostrum animi facere mollitia, corrupti vitae, itaque maiores consequatur, explicabo, sapiente molestiae consequuntur! Aliquam hic dolorum atque dolorem repudiandae nostrum optio praesentium quisquam vero. Nostrum illum modi aut, ratione qui! Quas laudantium, soluta asperiores minima molestiae similique consequatur ut.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda ad tenetur, numquam aliquid excepturi fuga. Pariatur numquam rem possimus, optio voluptate aspernatur ex, ipsum tenetur earum molestiae nulla suscipit sequi labore fugit repudiandae natus? Nam vel rem, rerum maxime harum. Molestias suscipit quaerat molestiae dolores fuga earum modi, distinctio repellat, laborum commodi quibusdam ex dolore, eius maiores architecto necessitatibus. Repellendus a vitae, est nesciunt. Aspernatur fugiat labore cumque, optio, magni, aperiam ut totam error eligendi iure culpa illum dolorum quam?
\ No newline at end of file
diff --git a/_posts/2015-03-01-code-syntax.md b/_posts/2015-03-01-code-syntax.md
deleted file mode 100644
index ee01cf5909..0000000000
--- a/_posts/2015-03-01-code-syntax.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Code Syntax
----
-To insert highlight code inside of a post, it's enough to use some specific tags, has directly described into the [Jekyll documentation](http://jekyllrb.com/docs/templates/#code-snippet-highlighting). In this way the code will be included into a ``.highlight`` CSS class and will be highlight according to the [syntax.scss](https://github.com/mojombo/tpw/blob/master/css/syntax.css) file. This is the standard style adopted by **Github** to highlight the code.
-
-This is a CSS example:
-{% highlight css linenos %}
-
-body {
- background-color: #fff;
- }
-
-h1 {
- color: #ffaa33;
- font-size: 1.5em;
- }
-
-{% endhighlight %}
-
-And this is a HTML example, with a linenumber:
-{% highlight html linenos %}
-
-
-
Example
-
-
-{% endhighlight %}
-
-Last, a Ruby example:
-{% highlight ruby linenos %}
-
-def hello
- puts "Hello World!"
-end
-
-{% endhighlight %}
diff --git a/_posts/2015-03-19-typography.md b/_posts/2015-03-19-typography.md
deleted file mode 100644
index 205c0daa55..0000000000
--- a/_posts/2015-03-19-typography.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Typograhy example
----
-
-Lorem ipsum dolor sit amet, [consectetur adipisicing](http://www.example.com) elit. Id, aliquam magni et officiis nemo nihil aliquid placeat alias. Eum voluptates ducimus, nobis ex illum laboriosam quidem corrupti impedit ratione in voluptatum amet beatae facilis temporibus voluptate praesentium voluptatibus! At ab, iusto error amet eveniet debitis ipsa recusandae possimus minima sunt itaque, nulla ducimus officia, consequatur ipsum laudantium magnam hic fuga vero incidunt nostrum. Commodi, perspiciatis ut nostrum fugit nulla cumque voluptate harum nemo accusamus?
-
-## This is a h2
-
-### h3, h4, h5 and h6 have the same style.
-
-Lorem ipsum dolor sit amet, consectetur adipisicing elit. Voluptas sed quo atque *perspiciatis*. Eius cum possimus, maxime unde, asperiores neque blanditiis molestiae ipsa odit. **Laboriosam**, error! Ipsa officia magnam at ratione commodi porro nulla consequuntur eum quia nisi officiis cupiditate reprehenderit provident facilis rem, nobis quidem fugiat, et! Tempore maiores reprehenderit laboriosam rerum?
-
-> This is a blockquote
-
-### Unordered list
-- list 1
-- list 2
-- list 3
-- list 4
-
-### Ordered list
-1. one
-2. two
-3. three
-4. four
\ No newline at end of file
diff --git a/_posts/2019-03-18-small-text.md b/_posts/2019-03-18-small-text.md
deleted file mode 100644
index ff7f30d2e1..0000000000
--- a/_posts/2019-03-18-small-text.md
+++ /dev/null
@@ -1,4 +0,0 @@
----
-title: Small text
----
-This is an example of a blog post with small amount of text.
\ No newline at end of file
diff --git a/_posts/2019-07-18-hello-world.md b/_posts/2019-07-18-hello-world.md
new file mode 100644
index 0000000000..0e7e552cf8
--- /dev/null
+++ b/_posts/2019-07-18-hello-world.md
@@ -0,0 +1,25 @@
+---
+date: 2019-07-18
+author: jw
+title: "Hello world. A much needed update on life, work, and my musings"
+description: "It's been a long time since I updated my blog. I've decided to make some changes and focus my blog on developer marketing, relations, and open source community building. Here's what I've been up to."
+categories: [work, personal]
+tags: [Personal Update]
+---
+Excuse my cliché title, it's been a while since I've published anything, and to be honest, it has lost its hard-won sense of familiarity. Publishing my personal and professional thoughts is an activity that I enjoy maybe even love.
+
+
Forging a new path.
+I cannot emphasize enough the impact that publishing content online has had on my career, but it's been all over the place. Web trends constantly come and go, if you catch them quick enough, you can leverage the wave of attention. But like everything, those waves die. This is why I'm moving away from publishing on Medium. Medium is a great platform, that has developed a diverse culture consisting of many different thoughts, topics, writers, and beliefs. Unfortunately, for me, it meant trying to focus on too many topics.
+
+
Focusing in.
+I've titled this blog 'A developer marketing blog.'
+
+Moving forward, I'll be sticking to two topics; Personal thoughts and professional thoughts, undoubtedly interlaced and entangled. Professionally, I'll be focusing in on marketing, with an emphasis on developer and open source audiences. Personally, I will be documenting my musings as a husband, father of three, and my career development.
+
+
In closing.
+As always, the opinions that you will find in my posts are my own, they are taken directly from my current views on life, which I expect will change as I grow and experience more. Life is a journey, you can follow mine or ignore it ... trolling is unappreciated.
+
+All is grace,
+
+Jesse
+
diff --git a/_posts/2019-07-22-devmarketing-communities.md b/_posts/2019-07-22-devmarketing-communities.md
new file mode 100644
index 0000000000..bd01c323c0
--- /dev/null
+++ b/_posts/2019-07-22-devmarketing-communities.md
@@ -0,0 +1,51 @@
+---
+date: 2019-07-22
+author: jw
+title: "Everything you need to know about developer communities and how to approach them."
+description: "An overview of the top five developer communities that developer marketing and developer relations teams should leverage."
+categories: [work]
+tags: [Developer Marketing and Open Source]
+---
+One of the main reasons I’ve been inspired to publish again is the lack of quality developer-focused marketing content. Developer marketing is my bread and butter and when, or maybe I should say if you figure it out, it’s an incredibly enjoyable audience to interact with. That being said, it’s an uphill battle. Developer audiences require you to have a deep understanding of the technologies that matter to them, emerging trends, communication styles, niche interests, and of course the communities where they spend their time. In this post, I want to introduce you to the less-known online developer communities.
+
+
Why are they all forums?
+Please note, I’m not sharing this information so that you can SPAM developers audiences more efficiently. When it comes to developer communities, your impact is predicated on the value you can provide. This is one of the main reasons why developer communities are almost always built on forum-style platforms.
+
+Developers are problem solvers. They take the time to engineer and craft solutions in methodical and thorough ways and they are constantly looking for better, faster, more secure ways to do their job. In addition, they value the distribution of knowledge, and are open to sharing and seeking knowledge from their peers. Forums are the most logical way to support this type of interactive community.
+
+
How do you interact?
+Every community is slightly different, but they all have one thing in common, authority rankings based on the value provided overtime. As users interact, they gain klout with the communities which are usually displayed in their profiles and impacts how their posts or comments get ranked. The more positive interactions that a user has, the more visibility and weight they carry in a community.
+
+Building klout is all about engagement. Users who try to game the system or spam the community are easily identified and weeded out. But that doesn't mean that they don't bring value to your developer marketing strategy. Marketers should keep an eye on forums and identify conversations and topics where they or their team can bring a level of expertise to the conversation. Forums are also valuable for keeping a pulse on the technology trends and challenges that developers are currently working on.
+
+When you do engage, make sure that you're comments are unbiased. Try to point users to open source projects that can solve meet their needs and try to acknowledge the solutions provided by other participants in the thread. As always, you will find individuals who are aggressive on threads, it's usually better to just ignore their comments and let the community mods engage with them if needed. The final piece of advice I'll give you is to try and truly become part of the community, faking it until you make it is not an option and if your intentions are not genuine people will know.
+
+
Did I mention there are a few of them?
+A quick Google will reveal that there is no shortage of developer communities, Reddit, Hacker News, Stack Overflow, and GitHub are arguably the most popular, but those are just scratching the surface. Below are a handful of communities that are usually overlooked because they don't advertise themselves or are just getting started. I would encourage you to pick one or two communities and focus the majority of your time there.
+
+
+
+
1. Lobste.rs
+
Lobsters is a Hacker News style forum with a few key differences that make it a unique place. First, Lobsters is an invitation-only community. You have to know someone to get an invite or ask for one on their IRC. Second, Lobsters has a 'hat' feature that lets members verify their profiles to earn a hat. Hats indicate a level of authority on a topic which allows a member to speak on behalf of a project, organization, or company.
+
+
+
+
2. Slashdot
+
Slashdot is a forum-based community that is relatively unknown. Unlike the rest of these communities, Slashdot was founded during the Dotcom era and is still going strong. It's a highly technical community with strong mods. This community is unique because of the ability to filter comments by type: Insightful, Informative, Interesting, and Funny. This limits thread clutter and allows users to engage with content in their preferred way.
+
+
+
+
3. Hashnode
+
Hashnode is an up-and-coming developer community picking up a ton of steam. It was birthed out of the desire for developers to have a place to start a conversation and get quality and most importantly friendly responses. Hashnode is more than just a forum, it features QAs, AMAs, submitted stories and a blogging platform. Unique to Hashnoed, they feature an open ranking system based on how helpful a user is.
+
+
+
+
4. Dev.to
+
Dev.to is another up-and-coming community. Dev.to focuses on providing a place for developers to advance their careers by asking questions. Dev.to is based around a #tagging system that allows you to personalize your experience. It's almost like Sub-Reddits, but not quite as separate. Dev.to was clearly designed to appeal to the next generation of developers with an almost GitHuby feel.
+
+
+
+
5. CodeProject
+
CodeProject is another online forum for developers. It's one of the larger communities, boasting over 14 million members. CodeProject focuses on long-form technical content and is not specific to a language, framework, or role. CodeProject feels like a combination of Reddit and Stack Overflow but without some of the more hostile tendencies.
+
+
diff --git a/_posts/2019-07-24-developer-buying-journey.md b/_posts/2019-07-24-developer-buying-journey.md
new file mode 100644
index 0000000000..f81df07fe5
--- /dev/null
+++ b/_posts/2019-07-24-developer-buying-journey.md
@@ -0,0 +1,51 @@
+---
+date: 2019-07-24
+author: jw
+title: "Understanding the developer buying journey - Part 1"
+description: "An overview of the developer buying journey, how to sell to software developers, and the developer marketer's role in the sales process."
+categories: [work]
+tags: [Developer Marketing and Open Source]
+---
+Developer as a marketing persona has been around for a long time. If you Google developer marketing, you can find content targeting that niche published almost 10 years ago. So you have to ask, why is it just now becoming a hot topic for enterprise companies? I believe that there are three main drivers of this trend. First, increased competition around the products developers use has exploded. Second, as Horowitz would say, "Technology is eating the world." Almost every company employs or contracts out to developers in one way or another. Finally, our visibility into funnel analytics has revealed a cohort of users who don't follow the expected buyer journey, yet play an important role in software sale.
+
+
"34% of opportunities are lost as the direct result of developer influence." Luke Kilpatrick
+
+
The developer persona as it relates to the sales process.
+Recently CEB released updated research around the personas associated with an enterprise buying group. They identified and broke individuals that influence a buying decision, into 7 different types:
+- The Go-Getter
+- The Skeptic
+- The Friend
+- The Teacher
+- The Guide
+- The Climber
+- The Blocker
+
+They then divided these types into two categories, mobilizers, and talkers. When you overlap these individual types with buying criteria, (think BANT or ANUM) you can identify and engage the right individual, with the right ask, at the right time while avoiding individuals who slow the progress of your opportunity. In theory, it's the perfect framework to guide you through the sale process ... Until you look at the developer persona and how developers make purchasing decisions.
+
+Unlike other buying personas, developers do not assume a single type or state, instead, they transition through the various types as their familiarity with the product progresses.
+
+Developers almost always start their journey as skeptics. They might evolve into blockers if your product doesn't work, or teachers if it does. Eventually, depending on circumstance, they can evolve into a guide who evangelizes your technology and helps other developers understand it and if you're lucky go-getter, advocating for your solution internally.
+
+If your team can provide the resources needed for a developer to move through the stages of their journey at their own pace, they will begin to form what could be called a 'buy-in group'. Buy-in groups are different than buyer-groups because their motive is not to make a purchase. Their motive is to maintain consensus around the best solutions for their organization. This is why developers do not fit into a typical sales framework.
+
+
an open buying journey
+The second place where developers break the stereotypical sales framework is how solutions are identified and qualified. Though nothing is absolute, the developer buying journey often starts with open source. Open source communities are where innovation in the tech world happens. Open source projects live outside of the confines of any single corporate agenda and are usualy guided by a unified vision of the future. Additionally, open source projects can be used and evaluated for free. They can also be built on or customized however the developer would like.
+
+When developers identify an issue they tend to shop for solutions that are open source. But that poses a few problems. Open source is not always the most practical or secure solution. Open source projects don't come with support, there is no way to guarantee who can and cannot contribute, and most importantly you can never really know how secure the codebase is.
+
+Because of this, developers begin moving downstream from open source projects to identify the products which are built on top of them. By the time a developer gets downstream, their buying decision has already been made.
+
+
a marketers role in a developers world
+If developers are going upstream to identify solutions, what can marketers do to shape the buying journey?
+
+When we look at a typical consensus sale, it's usually lead by the head of whichever part of the organization where the tool or service will be used. Those individuals generally make the decision for their entire organization, they might get feedback or take their teams opinions into account, but at the end of the day, what they say goes.
+
+Developers, on the other hand, don't work this way. There is rarely a single developer who speaks on behalf of all the developers in an organization. This is where we get back to the 'buy-in' group. Once the solution has been identified the developers on their team will validate the solution for themselves. It's up to the developer marketing team to make their solution the obvious choice.
+
+Accomplishing this easier said than done. Developers will generally choose a product based on the perception of your company concerning the upstream (open source) project. Do you make valuable contributions to the project? Are you experts on the project and the underlying technologies? How deep is the value that you bring to the table?
+
+It's the job of the developer marketer to make sure that these questions are being answered visibly. This looks like including the upstream project name and branding in your marketing material, showing up to support the upstream community at events, participating in their community meetings, and amplifying the projects marketing efforts.
+
+
Love what you read?
+
Check out part 2. Understanding the open source business model.
+
Check out part 3. Understanding the developer buying process.
\ No newline at end of file
diff --git a/_posts/2019-08-01-opensource-developer-buying-journey.md b/_posts/2019-08-01-opensource-developer-buying-journey.md
new file mode 100644
index 0000000000..643a788463
--- /dev/null
+++ b/_posts/2019-08-01-opensource-developer-buying-journey.md
@@ -0,0 +1,42 @@
+---
+date: 2019-08-01
+author: jw
+title: "Understanding the open source business model - Part 2"
+description: "Part 2 of the developer buying journey. How to use open source projects and communities enable the developer buying process."
+categories: [work]
+tags: [Developer Marketing and Open Source]
+---
+
+
A line drawing by Pablo Picasso | What's with the random art?
+
+This is the second part of my previous post insights. the developer buying journey , where I walked readers through how the developer persona interacts with the buying process and their role in a sale. I briefly touched on how open source projects play into the buying process, but would like to spend a bit more time on it in this post. In addition to covering open source, I'll spend some time on the value of creating a developer program to build community and affinity around the projects that you contribute to.
+
+why open source?
+I have a very strong belief that the future of software is open. There are a few reasons for this. Mainly, the enterprise is always pushing for the standardization of technologies, which allows business to seamlessly happen at a global scale. However, regardless of the efforts made by enterprise organizations, standardizations are rarely lead by the enterprise. When they are, there is always a competitor that pops up and puts them back to square one. Maybe this is because we inherently rage against the machine or maybe it's because even when working together the enterprise is still competitive? Regardless, open source is community-driven and inherently winner-take-all game. Ultimately, creating a standardization (aka adoption).
+
+Wondering if I'm making this stuff up? Here's some data by The New Stack .
+
+The second reason is that open source attracts the brightest minds resulting in the best solution. The top open source projects receive contributions from developers across various organizations, they are not limited to a select talent pool like a corporation is. Making a contribution to an open source project is difficult. The code review process is in theory done by a community of developers all invested in the success of a project. If your contribution is not up to par, it's rejected. This sets the bar very high for participants in open source communities, much higher than the expectation in an enterprise organization.
+
+open source and bottom-line growth
+Now that you know why I belive in and push involvement in open source, let's talk about the most common argument for limiting involvement in upstream communities. Conventional business theory would argue that investing in open source is a negative ROI activity that ultimately creates a competitive disadvantage for your organization. After all, if you give your software away for free, why would anyone buy it? The same principle holds for investing manpower into open source projects that you don't own or even directly build on top of.
+
+We need to consider what I wrote about in part 1 and how open source plays into the developer buying journey. (If you haven't, I suggest reading that post before you continuing through this one.) Open source should be viewed as a marketing activity, its ability to generate ROI is dependant on your ability to create what I like to refer to as hand-shake moments.
+
+Side note, if you wanna geek out, check out this post from back in 1999 by opensource.org - Making a business case for open source .
+
+By investing in open source you are participating in multiple high-impact activities. First, you are making an investment into the success of the projects that support your product. If the projects that support or even play a foundational role in your product die, you have big issues to deal with. Second, playing an active role in upstream communities builds brand affinity with developer communities. It's the proof developers look for when they question your expertise. Finally, you are creating paths from upstream communities back to your developer program.
+
+the value of creating a developer program
+Back to those hand-shake moments we mentioned earlier. We like to talk about open source as 'free-software' but that's a bit of an oversimplification. Open source licenses do have restrictions on usage which range from mild to severe. But more importantly, open source software can't just be deployed into a production environment. There is always a question about security, issues with scalability, not to mention basic maintenance, integration, and hosting.
+
+This is where the enterprise comes into play. The enterprise takes an upstream project and turns it into a product that can be consumed and put into production without the vulnerabilities and issues that are associated with an open project. They provide documentation for specific use cases and services to help implement the software which is how you create a business model based around open source software. Not to mention, no one wants to build the software that they build their software on ...
+
+Developer programs create a bridge from the upstream project to the enterprise product. They do this by providing value to the upstream community. As developers identify a solution upstream, they make the connection to the downstream product that will be approved by their security and legal teams. This is that hand-shake moment.
+
+Developer programs are a gray area, they are kinda upstream and kinda downstream. This grayness creates a safe place for developers to explore and learn without being pushed by a sales process. This doesn't mean that developers who are apart of your developer program are leads, but it does give you data on account interests that can be used as a leading indicator of an account entering a buying process.
+
+I hope this helps to bring the developer buying journey post to a close. Thank you to everyone who took the time to request a part 2 on slack or twitter.
+
+Love what you read?
+Check out part 3. Understanding the developer buying process.
\ No newline at end of file
diff --git a/_posts/2019-10-02-takeaway-evans-developer-marketing-conf.md b/_posts/2019-10-02-takeaway-evans-developer-marketing-conf.md
new file mode 100644
index 0000000000..3958a7a5b1
--- /dev/null
+++ b/_posts/2019-10-02-takeaway-evans-developer-marketing-conf.md
@@ -0,0 +1,77 @@
+---
+date: 2019-10-02
+author: jw
+title: "Key insights and takeaways from the Evans Data Dev Marketing Summit"
+description: "I recently had the honor of speaking and attending the Evans Data Developer Marketing Summit, here are some takeaways"
+categories: [work]
+tags: [Developer Marketing]
+---
+
+A piece my wife and I recently purchased by Davis Camp DeLisi | What's with the random art?
+
+Last week I had the opportunity to attend and speak at the Evans Data Developer Marketing Summit in San Jose, CA. It was a very insightful experience where I was able to collaborate with and learn from the individuals leading and growing developer marketing activities at Microsoft, IBM, Square, DocuSign, Bluetooth, TomTom, GM, and many more. Here are some of the data developer marketing data points that I found interesting.
+
+P.S. I had several requests to turn my talk into a blog post. It should be ready later this week, so keep an eye out.
+
+In addition to sharing these data points, I've added some commentary and thoughts on why this data point is valuable for developer marketing organizations.
+
+Developer data points:
+- The most important drivers for developers 1. Curiosity, 2. Skill development, 3. Benefiting the community
+
+- Biggest hackathon driver, educational projects benefiting children, specifically around education for children
+
+- Top used operating system is Windows 10
+
+- 100% of surveyed developers use more than one language over 50% of the time
+
+[comment] This is an important data point that many programs overlook. It's easy to get stuck in a content rut, where you only create new content for a specific language, not realizing that the developers using your product have additional dependencies, even if it's as simple as something like SQL.
+
+- 66% use scripted languages at least 50% of the time
+
+[comment] With the rise of node.js, react.js, etc. it is not surprising that developers are spending a ton of time using scripted languages. However, when I first saw this data point, I was caught off-guard.
+
+- Python is the fastest growing language
+
+- 60% of developers are primary decision-makers on a dev tool or technology sale
+
+[comment] This is a bit higher than I would have expected. I'm still not sure if I'm convinced that 60% are primary decision-makers.
+
+- 25% of developers are on a team that makes decisions together
+
+- Video sharing sites are the #1 sources of product and solution discovery
+
+- 27% are looking for ML and AI content
+
+- 80% of developers use non-IT sanctioned tools
+
+[comment] Not a surprise, unless you are in IT.
+
+- Webinars are the biggest driver of final purchasing decisions
+
+- Most developers attend 2-5 trade shows / year
+
+- Coding contests are the most exciting way to engage with developers
+
+- Hackathons and contests should not run more than one month
+
+- 60% of developers will not click on a tracking URL
+
+- Search ads are the most effective way to get in front of them
+
+[comment] This was a big surprise to me, I didn't believe it until we had a Q/A session with a developer focus group. One of the attendees brought it up and they agreed that search ads are valuable when they are looking for a new solution. The rational was interesting as well, they believed that companies that are paying to have their solution appear in front of them have resources, which is a good indicator that they will be around for a long time.
+
+Side Note: During our Q/A there were several instances where the developer focus group expressed distrust in 'startup' or new solutions.
+
+- Newsletters are the most appreciated form of marketing
+
+- Vendors are trusted as the most credible source of info on new technologies
+
+- 60% off technical audience members influence purchasing decisions
+
+- 87% read technical tutorials
+
+- 85% share technical tutorials that they read
+
+- 35% of developers find documentation a barrier to product usage
+
+- 34.5% of developers will reject purchasing decisions that have been made for them by their organizations
\ No newline at end of file
diff --git a/_posts/2019-10-16-talk-building-engaged-developer-communities.md b/_posts/2019-10-16-talk-building-engaged-developer-communities.md
new file mode 100644
index 0000000000..3ada956c78
--- /dev/null
+++ b/_posts/2019-10-16-talk-building-engaged-developer-communities.md
@@ -0,0 +1,63 @@
+---
+date: 2019-10-16
+author: jw
+title: "Notes from my presentation at the Evans Data dev marketing summit"
+description: "How to build developer communities, and why engagement is everything -notes from my talk at the Evans Data Developer Marketing Summit"
+categories: [work]
+tags: [Developer Marketing]
+---
+
+A few pieces from one of my favorite artists, Zhu Jinshi | What's with the random art?
+
+
+Last month I spoke at the Evans Data Developer Marketing Summit in San Jose. My talk was titled "Building Developer Communities. Why Engagement is Everything". The talk was very well received and I've had multiple requests to turn it into a blog post. The talk centered around why engagement is an important metric to focus on and then walked participants through how we are creating a highly engaged community.
+
+Why engagement is everything
+Before I dive in, you need to understand why I'm making the argument that engagement is everything. There are two reasons, first, engagement with your community is how you build trust. Second, engagement is the most cost-efficient way to build awareness on almost every channel. This is because content that has a high engagement rate is organically amplified by the community.
+
+When you look at a developer program there is a heavy emphasis on content. Product content, learning content, and marketing content. These three content types form the pillars that developer programs are built on. Content is what your community engages with, but creating content is not enough. Content must be served to an audience in a way that catches their attention and pulls them in.
+
+Engagement is a journey ... a long one
+When I started at Red Hat, the developer program was just beginning to transition out of its infancy. The team had invested in building most of the key components of the program but had not started building and implementing the processes needed to scale, while maintaining a level of consistency across all of our channels. Because of this, most of the data that I had access to was not trustworthy.
+
+The story that the data wanted to tell was missing because there was no consistency.
+
+The engagement metrics were all over the board. Some days were grand slams and other days were complete strikeouts. We needed to start testing but before we could trust the data that our tests produced we needed to create a controlled environment that we could benchmark against. Keep in mind that we're talking largely about social channels, so a true control will not exist. To solve for the many factors that go into content creation across all of our social channels, we focused our attention on consistency.
+
+Getting to step one
+If I breakdown our process, there would be three main stages that emerge.
+Creating a baseline strategy
+Optimizing that strategy
+Measuring our way to success
+By far, the hardest step is creating a baseline strategy. This is where that sixth sense that you develop after many years of marketing comes in handy. You take everything that you know about your audience and combine it with industry best practices. Once you've done that, come up with some secret sauce that allows you to cut through all of the industry noise.
+
+In no way is it a scientific or data-driven process, at this stage scientific is not the point. The point is to put your best foot forward and create a level of consistency that you can test against. To accomplish this, we created posting guides for each of our channels that included some basic 'dos and don'ts' along with style/tone guides, posting cadences, and focus topics for each channel.
+
+We gathered about one month of consistent data, which proved to be enough to confidently validate our baseline strategy and progress into our testing and optimization stage.
+
+Optimizing our strategy
+Because of the nature of our program, we tend to be more reactive in how and what content we promote. We have to work with the content that we were given. At Red Hat, there is no shortage of upstream projects, products, or topics so our content can be very diverse. On top of that, we don't make a big habit of setting hard delivery dates or assign content pieces to our authors, so most of the time we're working with whatever content falls into our lap that week.
+
+Since we couldn't depend on consistent topics, post type was the logical starting point for our testing and optimization. For those of you who don't live in the marketing world, post-mix is a very important and easily overlooked component of social engagement. Finding the right post-mix is important for building engaged audiences. A standard mix might include video posts, image posts, link posts, and text posts. We could define these as:
+
+Video post - Any post that has a video embedded
+Image post - Any post that has an image uploaded with it
+Link post - A text post with an image
+Text post - A post that does not have a link, image, or video. This would also include a poll or survey.
+
+With our data in hand, we spotted some fairly obvious trends. When our post consisted of just over 50% link posts, there was a greater engagement rate. Text posts had some of the highest engagement rates, but when they comprised more than 10% or our post-mix, we begin to see diminishing returns and engagement rates started to drop.
+
+The more consistent our tests were, the more trends emerged from our data to drive future tests. This is where it can become really difficult.
+
+Metrics to drive engagement
+The final step here is measuring your strategy. Most people will think this is fairly elementary, but I found that most teams either measure too many things or are not measuring the right things. At Red Hat, I have access to several marketing analytics platforms that generate close to two hundred data points. I would argue that there are maybe fifteen metrics that matter, the rest is just clutter unless you have a very specific question.
+
+When we talk about metrics we are talking about the data used to evaluate performance. When it comes to engagement there are two dangers with marketing metrics, it's often difficult to identify early indicators, which results in reactive vs responsive strategies. And, the second, is that we forget to factor in how metrics drive employee behavior.
+
+If our goal is to drive community engagement, focusing heavily on CTR will detract from your ability to achieve that goal. This is because your team will view your communities as a way to drive traffic at the expense of engagement. Additionally, CTR is a trailing indicator, it's what happens after someone has interacted or viewed your content. Liking, sharing, or commenting would be considered a leading indicator. These are subtle differences that define which teams can build engagement.
+
+I hope you've learned something and that the blog is as good as my talk ;)
+
+
+
+
diff --git a/_posts/2019-12-03-developers-and-bant.md b/_posts/2019-12-03-developers-and-bant.md
new file mode 100644
index 0000000000..064257f152
--- /dev/null
+++ b/_posts/2019-12-03-developers-and-bant.md
@@ -0,0 +1,36 @@
+---
+date: 2019-12-03
+author: jw
+title: "Understanding the developer buying process - Part 3"
+description: "The role developers play in an enterprise deal is evolving. How do developers buy the tools they use and do they have BANT?"
+categories: [work]
+tags: [Developer Marketing]
+---
+
+Bull by, Pablo Picasso | What's with the random art?
+
+
+There is a common belief in enterprise tech marketing circles that developers do not have a budget or purchasing ability. This assumption is based on standard enterprise sales processes focused on driving high ACV with multi-year terms. In many organizations this assumption holds true, however, it's changing quickly driven by fundamental shifts in how buyers interact with enterprise software. To stay ahead of this shift, developer marketers need to understand why that assumption originated, what's driving the change, and how to stay ahead of it.
+
+Developers and BANT
+BANT is a sales qualification acronym for budget, authority, need, and timing. It allows sales reps to quickly qualify new leads and opportunities. It's by far the most popular qualification criteria but isn't the only one (check out GPCTBA/C&I).
+
+In the past, developers had the need and timeline but lacked the budget or authority, which meant that developers were not the primary contact on an opportunity. However, it quickly became clear that though you could leave developers out of a deal and still get it closed, your ability to drive usage, renewals, and account expansion is almost impossible.
+
+This is where developer marketers and developer relations folks saw their rise to fame. Developers became a key audience member in a successful enterprise sale and ensuring the overall health/retention of the account. Fast forward fifteen years and the enterprise tech sales landscape is changing at the same pace as the technology that is being sold. To maintain a strong position in the market, enterprise software providers need to recognize the evolution and adopt.
+
+Public cloud providers changed the game
+With the rise of public cloud providers, software has fundamentally changed and so have the techniques and tools used to create it. Developers no longer work in environments hosted on local resources, they're moving to the cloud, and so are the tools and applications that they use.
+
+To provide a 'developer-friendly' experience, cloud providers have integrated developer tools directly into their offering. Providing a one-stop-shop experience where developers can build a stack à la carte with the click of a button. Along with configuration simplicity, cloud providers offer metered pricing and a self-service checkout experience.
+
+The ability to enter their credit card information and have a small reoccurring payment that automatically scales with their needs has shifted the power back into the hands of developers, making the BANT argument largely irrelevant. According to a recent Evans Data survey, 58% of developers indicate that they have budget and authority, not just budget influence. Organizations that are reluctant to move away from the classic enterprise sale process should be warned.
+
+It's the cloud's world we just live in it
+Cloud providers have made developer marketing more important. Persuading developers away from the expanding list of native product offerings included with a cloud subscription is difficult. Not to mention providing a self-serve purchasing experience that warrents retention and expansion without the help of an account manager is a challenge that only a few companies have figured out.
+
+Developer facing companies need to evolve quickly or risk extinction. They must acknowledge that developers do have a budget, and when it's easy, they will spend it.
+
+
+
+
diff --git a/_posts/2020-01-23-content-strategy-developer-program.md b/_posts/2020-01-23-content-strategy-developer-program.md
new file mode 100644
index 0000000000..d707487333
--- /dev/null
+++ b/_posts/2020-01-23-content-strategy-developer-program.md
@@ -0,0 +1,43 @@
+---
+date: 2020-01-23
+author: jw
+title: "Content strategies for developer marketing programs"
+description: "Three content strategies that can be used to drive engagement with developer programs."
+categories: [work]
+tags: [Developer Marketing]
+---
+
+A few pieces from one of my favorite pop artists, Banksy | What's with the random art?
+
+One of the core tenants of developer marketing is the understanding that developers as an audience are avid consumers of content. If you look at the most popular developer programs, you will notice that many of them achieve a publishing velocity that is unheard of in other marketing organizations. This is because content plays a major part in engagement strategies and ranges from product marketing content to educational content, and even documentation.
+
+For large organizations, it’s a numbers game. If you can hire enough technical content creators or reserve enough budget to buy high-quality content, you can achieve this goal fairly easily. However, if you are not a large organization with seemingly endless resources, meeting the content needs of a developer program can be much more difficult, if not impossible.
+
+In this post, I want to talk about a few different content strategies that if deployed correctly, can allow organizations of various sizes build a program that engages and meets the needs and expectations of developers.
+
+Developer content strategy 1 - The intent model
+Intent marketing is something that has been around for a longtime but for some reason is almost always ignored. If you are not familiar with intent marketing, intent marketing is a strategy that focuses on predicting and meeting the needs of your target audience before they express those needs. For example, most enterprise buying processes will require IT, SecOps, Legal, etc. review prior to signing a contract. An intent marketing strategy, would predict the need of an individual who is championing the sale to look for information required by those departments and proactively surface them.
+
+If you take that method and apply it to a content strategy for a developer program, it would look like building evergreen technical content that pulls developers through the discovery process (usually tied closely to an open source solution) into the evaluation process, and finally to the advocacy phase. By focusing your content strategy only on the immediate and direct needs of your specific developer audience, you limit the amount of unused or short-lived content that you might have invested in creating.
+
+For a small to mid-size organization, this is a great strategy to focus on that will provide a helpful and engaging program for your developers. Additionally, it keeps you from wondering off into edge cases, which is all too easy with developer content.
+
+Developer content strategy 2 - The pillar model
+When talking about content marketing, pillars are a common concept. Generally, we use this terminology around SEO strategies, using content pillars as building points for search rankings across a site. For this example, I’m going to use the term pillar to refer to content types vs topics. If you understand how content pillars work in SEO, you will see how that strategy can easily overlap this strategy and would work well when used together.
+
+Developer content programs consist of three main types of content, product marketing content, educational content, and technical documentation. This content might take various forms like video, code sample, long-form written, and even infographic or technical diagram. My point is that you can and should group all of your content into these three buckets. In fact, I would argue that most developer programs miss their mark because they do not define exactly what type of content they are producing. When the lines get blurred, the content will become confusing and the overall experience of the developer will begin to decrease.
+
+This is a strategy that is really important when you are working with large amounts of content and larger teams. By keeping your roles focused on a specific pillar, you keep your program feeling really genuine and impactful without overwhelming everyone on your team with sync meetings.
+
+Developer content strategy 3 - The reuse, repurpose, recycle model
+Most of you will know exactly where I’m going with this one based on the name. The reuse, repurpose, recycle model is a content strategy that should only be used by teams that have no other choice. Overtime, it has diminishing engagement value, but for early stage startups working on bootstrapping a program or productizing and upstream project, it could be just the right tool.
+
+This strategy focuses on building out a handful of really in-depth content pieces that meet the needs of +50% of the developers you are trying to engage with. It’s just enough to take a small amount of the burden off of your support engineers but not enough to make your team cringe at the thought of updating it as you release ... because that’s exactly what they will be doing. If you’re pursuing this model, I would plan on investing around twenty thousand dollars into creating this content. Hire a professional editor and work with the best technical writers, it will pay for itself in the end.
+
+
+
+
+
+
+
+
diff --git a/_posts/2020-02-18-interpreting-gitlabs-devsecops-report.md b/_posts/2020-02-18-interpreting-gitlabs-devsecops-report.md
new file mode 100644
index 0000000000..e96b424878
--- /dev/null
+++ b/_posts/2020-02-18-interpreting-gitlabs-devsecops-report.md
@@ -0,0 +1,30 @@
+---
+date: 2020-02-18
+author: jw
+title: "What GitLab's DevSecOps report means for developer marketers and relations"
+description: "Recently GitLab released its 2019 GitLab Global Developer DevSecOps Report, this is what it means for developer marketing professionals"
+categories: [work]
+tags: [Developer Marketing and DevSecOps]
+---
+
+A few pieces from American abstract artist, Mark Rothko | What's with the random art?
+
+
+The insights mentioned in this article have been gathered from the 2019 GitLab Global Developer Report: DevSecOps . Because the report is comprised mainly of GitLab users, we can assume that data related to technology vendor preference and usage are skewed, because of this I’ve intentionally ignored those topics in this post.
+
+Before we dive in, let’s quickly review why DevSecOps even matters to developer marketing professionals, after all, DevSecOps guys are IT right? Not quite ...
+
+With the emergence of infrastructure as code, the line between Dev and DevOps has become increasingly blurred. In fact, the majority of developer marketing and developer relations orgs will tell you that they group developer and DevOps titles into the same audience segment. For developers, this line blurring has enabled agility and increased release velocity, but it left something out ... IT security. This is where DevSecOps made it’s debut. DevOps ensures rapid development cycles, but lengthy security practices frequently undermine DevOps initiatives. DevSecOps focuses on integrating security into the development lifecycle and automating it, removing the roadblock of IT/SecOps.
+
+One thing that I really like about this report is that the team at GitLab broke DevSecOps into three separate components when surveying their audience (Development, Security, Operations) which I think removes a lot of the confusion and ensures that the responses are more accurate.
+
+The first thing that really stands out about this report is that the definition of how an organization would ‘do’ DevOps, is not set in stone. For software vendors, this is really important to note. Many times as vendors, we assume that the majority of software teams conform to a specific workflow. In reality, most teams are a mashup of various methodologies and disciplines, not to mention the technologies they are using to enable those practices. It’s also good to know that DevOps is not universally viewed as having a positive impact on an organization, it also varies in degree of automation vs manual tasks. Developer Marketing teams should use the term DevOps conservatively, I would suggest clearly articulating exactly what you mean with the term DevOps and making it publicly available and referenceable to those consuming your content.
+
+Second, deployment frequency and velocity is a major driver for teams pursuing a DevOps strategy and for developers it’s a major influence on job satisfaction and innovation. This by itself is not a new or interesting insight, until you consider security as the biggest roadblock for deployments. Removing this roadblock is why DevSecOps is gaining popularity, however, shoving the word Sec in the middle of DevOps does not make everything smell like roses. As the report states “Security is perhaps the most polarizing aspect of software development today...” Why does it matter for developer marketing teams? As marketers, we love our keywords and tag-lines. Security makes headlines and fear sells stuff, it’s easy to place a heavy emphasis on security in your product copy, but you should be aware that by adding mention of security features you don’t get an automatic thumbs up. This is another word that should be used sparingly and with heavy context, it should be noted that security measures vary from company to company and industry to industry. Though your product might be ‘secure’ for a small private sector company, it most likely doesn’t come close to meeting the compliance needs of an organization working in the federal space. Final note on security, early indication and automation is a big deal to software developers. They want to know that the tools they are using to write code will catch security issues, this goes back to contextualization of the term security in your collateral.
+
+Third, 36% (the majority) of developers think that their organizations DevSecOps practices rank as ‘Fair’. This is credited and tied closely to how mature the organizations DevSecOps strategy is. Not surprisingly, when a DevSecOps strategy is mature, it is 3x more likely to discover bugs before the code is merged (see final point above). Teams that have a mature DevSecOps strategy are very happy with it, however, it’s a long journey and most dev teams don’t have a solid grip on it. For developer marketing and relation teams, this is a great data point. Developers are heavy consumers of educational content, DevSecOps workshops and talks will most likely be a focus area for companies looking to sell their solution into a developer org.
+
+Final point, on the operations side of things, there seems to be much less ambiguity. This is because of the heavy focus on tools and automation. I would also argue that the industry as a whole has focused heavily on developing Ops infrastructure and practices, making it the most mature area of the DevSecOps trifecta. Ops has clear priorities and and structured workloads allowing them to easily measure their work. When we look at monitoring, CI, and deployment tools, there is no clear winner. For developer marketers this is important to note. When focused on Ops, don’t emphasize a one-tool-fits-all approach with integration partners. You should expect to gain search traffic that is focused on an organizations specific stack vs a methodology or practice.
+
+Conclusion
+Personally, I found this report to be informative and generally speaking align with what I see reflected in my own developer campaigns and audience behavior. There are a few takeaways from the DevSecOps report that I think will play a role in my upcoming marketing campaigns. Most importantly, on the DevOps side, it’s a good reality check on the maturity, adoption, and affinity to the topic. It’s very easy to assume that DevOps is a well established standard, but the reality is that it is far from that. Speaking of standards, standardization in general is simply non-existent. We have a long way to go with the DevOps topic and I will be reviewing my own content to make sure that I don’t make false assumptions about the readers understanding of the topic aka, diving too deep too fast. It’s fun to cater to developers on the bleeding edge, but ensuring that developers who are slow to adopt can still find 101-level content is important. Additionally, I’m going to be taking a close look at how ‘security’ is talked about, focusing in on the aspects that are integrated into developer tools like IDEs. I would encourage you to checkout the full report here .
diff --git a/_posts/2020-03-06-personal-update.md b/_posts/2020-03-06-personal-update.md
new file mode 100644
index 0000000000..c6e549b168
--- /dev/null
+++ b/_posts/2020-03-06-personal-update.md
@@ -0,0 +1,40 @@
+---
+date: 2020-03-06
+author: jw
+title: "Joining Amazon Web Services (AWS)"
+description: "2019 was a busy year, a ton has happened since my last update post. Here's what's new."
+categories: [work]
+tags: [Personal Update]
+---
+
+A few pieces from an icon from the LA art community, Ed Moses | What's with the random art?
+
+It’s been eight months since my I re-launched my site. Since then, I’ve been pushing off a personal update post. There have been a ton of new happenings in my world. Needless to say, life is moving fast and though at times it can feel like a whirlwind, though I wouldn’t change anything about it.
+
+When I reflect on my career, I can’t help but be grateful. Unlike many young professionals who spend five to ten years exploring and looking for roles that they love, I managed to find my path easily. Each step seems to build on top of the last in a perfectly orchestrated way, and though some steps can be hard to make, in the end it always works out for good.
+
+One of the harder steps took place at the end of 2019, when I transitioned out of Red Hat to pursue a role at Amazon Web Services (AWS). Working at Red Hat was a dream come true for me. I love open source and believe that open source already is and will continue to be the most viable strategy for enterprise software development. Red Hat sits on the bleeding edge of open source in enterprise, with 25 years of experience in the space and a model that has generated billions in revenue, more recently notching the largest software acquisition ever.
+
+My time at Red Hat was an experience that I’m incredibly grateful for. Learning the open source business model, having an inside perspective of the acquisition process, and helping to lead the day 1-30 messaging for our developer audience was a once in a lifetime opportunity. Along with the work experience, there were many intangibles that I gained, like a network of highly intelligent peers, an in-depth understanding of the underlying technologies in Red Hat’s very broad portfolio, and ultimately the job experience that led to my current role.
+
+Several people have asked me if my transition from Red Hat was due to IBM’s acquisition of Red Hat. The simple answer is no, it wasn’t. The longer answer is yes, in some ways. There are a ton of factors that go into making a decision to leave a role, lifestyle preferences, compensation, career vision, job satisfaction, just to name a few. When I look at the factors that drove me to towards AWS to most people’s surprise, it’s mainly lifestyle preference.
+
+Red Hat is based in Raleigh, and though it’s an incredibly ‘remote friendly’ workplace, no matter where you work careers are built on relationship and relationships happen in person. Pulling this off required travel, a ton of travel. In 2019, I spent over 60 nights in hotels. As a husband and father of three young children, the burden was greater than I had originally expected and the requirement to travel seemed to grow as my role in the organization expanded.
+
+When IBM acquired Red Hat, the motto was that ‘Red Hat is still Red Hat.’ For a company the size of Red Hat, sustaining your internal ethos and resisting a thorough ‘blue washing’ is not an easy task. The leadership at Red Hat has not let up on that vision, and (at least when I was there) have done everything in their power to keep all the things that make Red Hat a unique place intact. Ultimately though, in many ways the fight to maintain Red Hat’s independence had an opposite effect. Preserving the things we love tricked us into imposing the same bureaucracies we resent. Fear and uncertainty can drive the most stable individuals to act out of character, and though lines of communication remained open, competing with IBM’s reputation for rolling layoffs and employee distrust proved to be a challenge for some.
+
+I’ve always tried to maintain a high-level of intentionality when it comes to my career. I believe that careers are crafted and that success isn’t something that the majority of us simply stumble upon. The DC tech scene is an interesting place, unlike most tech hubs that are sustained by VC dollars, DC tech thrives on government contracts, consulting, and regulation. The deeper my family’s roots grow here, the more obvious it becomes that my future depends on the ability to operate in the public sector space.
+
+When AWS contacted me about a role at HQ2 (just a few miles from our home in Alexandria, VA) I saw an opportunity to keep the momentum in my career as a developer marketing specialist rolling, while balancing the demands that my career was placing on my family. The role is public sector facing, with global scope, and a local team. A dream job, that seemed to fall right into my lap.
+
+To be completely honest, at first, I did not think I was going to get the job. Usually when things seem too good to be true, they are. Despite my doubts, I agreed to an exploratory call with the recruiter and figured that the worst possible outcome is remaining in my current role, which was going great. Needless to say, the call went well as did my intro call with the hiring manager, which lead to one of the most unique and impactful processes of my career.
+
+Amazon is a fascinating place. Internally the term ‘peculiar’ is used to describe the culture, and the interview process was nothing short of that. Amazon interviews focus almost entirely around our fourteen leadership principles, which are the foundation of what makes Amazon such an incredible place to work. Candidates are expected to understand the principles and identify specific instances that demonstrate the preexistence of those principles in workplace scenarios. The final step of the Amazon interview process is an on-site that lasts for about six hours, comprised targeted questions relating to the fourteen leadership principles. It’s a marathon, and like a marathon, it requires preparation.
+
+My interview fell the week after the Thanksgiving holiday, which gave me a ton of time to prep. I ended up spending the first two to three hours of the day prepping furiously before my kids woke up. Recalling specific instances from my career that relate to each principle required a ton of reflection. There were instances where I did the right thing and others that I wish I could have a second shot. As time went on I began to internalize the leadership principles and the value became increasingly clear. If that was the extent of my interaction with Amazon, it would have been worth every second. Luckily, I get to spend a lot longer here.
+
+A few people have questioned my reasons for joining AWS, eluding to a workaholic cutthroat culture. I can’t speak on behalf of every Amazonian, but my experience has been anything but that. Amazon is a challenging place to work, we take on big projects, we strive for high-levels of excellence, and we work hard. Those same challenges are what make it a highly-rewarding place to work.
+
+For those who are wondering what I do at Amazon (Hi mom!), I work for Amazon Web Services (AWS) which is a subsidiary of Amazon and is the most broadly adopted cloud platform. For some, that’s gibberish, in which case, we’re a platform that provides the resources for developers build really cool stuff … like the stuff in the video below.
+
+VIDEO
\ No newline at end of file
diff --git a/_posts/2020-03-18-what-is-a-developer-program.md b/_posts/2020-03-18-what-is-a-developer-program.md
new file mode 100644
index 0000000000..b7e1b61039
--- /dev/null
+++ b/_posts/2020-03-18-what-is-a-developer-program.md
@@ -0,0 +1,59 @@
+---
+date: 2020-03-18
+author: jw
+title: "What is a developer program and what does it take to build one?"
+description: "Developer programs are a growing part of the enterprise software go-to-market strategy, here's how to build one."
+categories: [work, personal]
+tags: [Developer Marketing and Programs]
+---
+
+Blue I, II, III, 1961 by Joan Miro | What's with the random art?
+
+
+If you’ve followed me for any amount of time, you’re well aware of the level of importance that I place on developers. We currently find ourselves in an interesting place where the thought of ‘software eating the world’ is no longer shocking, in fact it’s old news. Software has eaten the world and has taken a foundational seat in ANY and ALL types of business. Though it has taken almost twenty years, developers hold the fates of every major fortune 1000 company, every emerging disrupter, and every struggling turnaround, with the ability to shift entire markets with a few lines of code. For the enterprise, developers are a key person to include in growth strategies, but it’s much easier said than done. Developers require a very different type of marketing that has led to the emergence of marketing activities that focus on technical end-users which we call ‘Developer Programs’. This post will explore developer programs and what makes a good one.
+
+In earlier posts, I outlined how the developer persona relates to sales and marketing , how open source impacts developer marketing , and the developer budget debate . If you haven’t read those posts, I would suggest that you take a moment and read through them. In this post I’ll make the assumption that we share a basic understanding of developer marketing, the developer persona, and the open source business model.
+
+Developer program definitions
+Marketing terminology is ambiguous at best and incomprehensible at worst. Throughout this post, I will be using several marketing terms that will be interpreted differently from one reader to the next. To mitigate confusion, lets standardize on a few of terms. A ‘Program’ is defined as an integrated marketing effort targeting a single audience. Programs have dedicated budget and headcount, and generally operate outside of the broader go-to-market, to achieve a very targeted objective. Program headcount usually extends beyond the roles in a marketing organization to include product managers, technical advocates, and even dedicated engineering teams. Programs are comprised of ‘Elements’ and ‘Campaigns’. A ‘Campaign’ is a marketing activity which has a defined start and end date. ‘Elements’ are the opposite, they’re an activity which does not have a defined start and end date. Elements can extend beyond a marketing activity to include assets that require ongoing investment, like a software plugin hosted in a competitor’s library. I should also note that programs have a defined membership status, individuals are either a part of it or not a part of it.
+
+Developer program advocates, tools, and marketers
+Developer programs are a collaborative effort between developer advocates, developer marketers, and in most cases an engineering team focused on developer tools. When working properly, these three roles create a virtuous cycle. Developer marketers push a solution into the market, developer advocates receive feedback on the solution, the feedback is incorporated by the engineering team, ultimately being pushed back into market completing the loop. It should also be noted that the developer advocacy and relations role play an unequally important role. Developer advocates often times direct the organizations unique point of view and communicate it to customer developers, crafting a vision for how to use the tool and shaping the buying vision. Without this guidance, marketing is generally irrelevant and the product will struggle to gain adoption.
+
+Developer program content and product offerings
+Developer programs can be distilled into two main components, content and product. Content includes everything from social posts to speaking engagements. Product includes the software that you are bringing to market and the program offering (e.g. $100 of free compute, a login page, a member only site functionality). Content is the most important aspect of a program, developers devour content, and programs that are able to satisfy a community’s consumption needs are able to grow at an incredible rate. When creating a content strategy, it’s important to balance your investments across three types of developer content, product content (docs, release notes, roadmaps), marketing content (thought leadership, SEO, feature/partner announcements), and educational content (eBooks, cheat sheets, tutorials, workshops). It’s also important to diversify content across multiple mediums (short and long-form written, video, presentation). Content can be viewed as a way to attract and build community; however, a poor product experience will quickly undermine the success of your content strategy (that includes documentation).
+
+Product is what separates the programs that thrive long-term from those that are just a flash in the pan. Developer tools are difficult, it can take years to gain significant levels of adoption, all the while navigating a rapidly evolving and shifting landscape. Similar to content strategies, product strategies need to balance investments in several areas. The first area is understanding the current developer tool landscape and integrating into that landscape seamlessly. The second area is predicting which emerging technologies will shape the future landscape and crafting a strong POV on that future state along with the tools to back it up. This is where having a strong open source strategy can pay dividends. Open source is where innovation happens, making it far more beneficial to investing in monitoring what’s happening in open source communities over what your competitors are doing.
+
+What makes a good developer program?
+The quality of a developer program is dependent on the program’s ability to create business value without compromising developer affinity. Programs that prioritize business value over developer affinity will come across as pushy and have a hard time retaining their audience, an early indicator of this is program unsubscribe rates. Programs that prioritize developer affinity over business value end up being a drain on the organization, an early indicator would be the adoption of developer tools or MAUs. Programs should drive measurable product adoption, affinity, and expansion, adding significant value to the organization’s bottom line.
+
+As with everything in business, the output will reflect the input. A developer program is often the sum of the team behind it. This will change based on the type of talent your organization is able to attract, but I believe that most programs can function with a core team of five.
+
+The DevRel - Generally speaking, your developer relations team will be the face of your program. They should have an excellent stage presence and a pre-established following; reputation is everything with DevRel folk. They should have a very strong POV that aligns well with the organization’s vision and be able to balance virtual and physical communication strategies.The PM - A strong product manager will be foundational to the success of your developer product offerings. They should be able to balance the DevRel strategy, the product vision, and the product roadmap, combining them together and delivering solutions that are easily adopted.The Dev Marketer - This is usually a PMM (product marketing manager) who has developed a very strong understanding of developers, most of the time that understanding comes from a background in some level of development. They have a knack for community building, understand the online communities where developers hangout, and have the ability to communicate to developers effectively.The Editor - Programs are built on content, making an editor a vital role on your team. Most of the time it will be almost impossible to create all of your content from inside your team, having someone on your team who can work with technical authors from across your organization, consume that content, and transform it into content that appeals to your audience is really important.The G2M - Go-to-market (G2M) is one of the most misunderstood roles in marketing/product organizations. G2M is an extremely strategic role, a good G2M will include market analysis, pricing strategies, competitive intel, positioning, messaging, and much more. In a competitive landscape (which is every tech landscape) having a G2M’s guidance is worth its weight in gold.
+
+It goes without saying that there are many other valuable roles like an event manager, a web manager, and even a project manager, however, the team above will allow you to build out the foundational aspect of your program.
+
+It should also be mentioned that most of the value that you will gain from your program will be directly tied to the metrics that you focus on driving. Developer marketing programs should focus on three main metrics, 1/ program growth, 2/ product adoption, and 3/ community engagement. Program growth is how many developers are joining your program vs community attrition. Obviously, you want to see a positive growth trend and it’s important that as you drive community growth that product adoption and usage increases. It’s also important to track how engaged your community is because it indicates of the health of your community and how impactful or detrimental your marketing efforts are. Maintaining a firm understanding what actions drive these metrics forward will keep your team focused on balancing developer affinity and business value.
+
+Conclusion
+As we continue our journey into this tech forward world that we live in, developer programs and developer marketing will continue to increase in importance. At the end of the day, every business is either an end-point-solution that is integrated into a platform or a platform solution that offers the ability to integrate into it. Attracting developers to build those integration ecosystems will play a key role in the future success of almost all enterprise businesses.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_posts/2020-04-02-thoughts-on-optionality.md b/_posts/2020-04-02-thoughts-on-optionality.md
new file mode 100644
index 0000000000..b6957b0784
--- /dev/null
+++ b/_posts/2020-04-02-thoughts-on-optionality.md
@@ -0,0 +1,10 @@
+---
+date: 2020-04-02
+author: jw
+title: "Maintaining optionality"
+description: "We often underestimate the impact that a single decision can have on our life. Maintaining optionality is key."
+categories: [personal]
+tags: [Thoughts on Life]
+---
+
+We often underestimate the impact that a single decision can have on our life. What seems like a no-brainer in the present can have devastating impact in the long-term. Many times, the decisions that hurt us most are the decisions that are made without a consideration for long-term optionality. At the end of our lives, our success or lack of success is oftentimes the sum of a million decisions. Those who achieve high-levels of success are the ones who manage to make more good decisions than bad decisions. Optionality is risk management. The more optionality a decision provides you with, the less risk you assume and the less you need to hedge. Low optionality decisions require significant hedging. No one can say what the future holds, optionality leads to adaptation which results in success.
\ No newline at end of file
diff --git a/_posts/2020-04-27-creating-developer-marketing-strategy.md b/_posts/2020-04-27-creating-developer-marketing-strategy.md
new file mode 100644
index 0000000000..786a4fcae0
--- /dev/null
+++ b/_posts/2020-04-27-creating-developer-marketing-strategy.md
@@ -0,0 +1,45 @@
+---
+date: 2020-04-27
+author: jw
+title: "Creating a developer marketing strategy"
+description: "How to create a developer marketing strategy that drives product adoption, awareness, and retention with developers."
+categories: [work]
+tags: [Developer Marketing and Programs]
+---
+
+Blue Nude by Henri Matisse | What's with the random art?
+
+
+Developer marketing is inherently complex. In fact, when it comes to developer marketing, it’s better to not even call it marketing. The reality is that marketing to developers can be simplified into two functions, developer relations and developer experience. In a recent post, (What is a developer program and what does it take to build one? ) I took some time to dig into the roles that are important to building a developer program. In this post, I’m going to take a step back and look at it from a slightly higher-level perspective. I’ve written a lot about the tactics that can be used to market to developers. Now, let’s look at the strategies that drive those tactics.
+
+When it comes to marketing, I structure my efforts around a strategy that is comprised of tactics like a program made up of elements and campaigns. Think of it like this, a strategy is your plan to move from A to Z, that can be as complex as world domination, or simple as building a community of 100K developers. Tactics are what move you from A to B, and B to C. They are mechanisms that when used together in an intentional way can create forward movement and momentum.
+
+Before we move on, let’s level-set on definitions from an earlier post.
+
+“Marketing terminology is ambiguous at best and incomprehensible at worst. Throughout this post, I will be using several marketing terms that will be interpreted differently from one reader to the next. To mitigate confusion, lets standardize on a few of terms. A ‘Program’ is defined as an integrated marketing effort targeting a single audience. Programs have dedicated budget and headcount, and generally operate outside of the broader go-to-market, to achieve a very targeted objective. Program headcount usually extends beyond the roles in a marketing organization to include product managers, technical advocates, and even dedicated engineering teams. Programs are comprised of ‘Elements’ and ‘Campaigns’. A ‘Campaign’ is a marketing activity which has a defined start and end date. ‘Elements’ are the opposite, they’re an activity which does not have a defined start and end date. Elements can extend beyond a marketing activity to include assets that require ongoing investment, like a software plugin hosted in a competitor’s library. I should also note that programs have a defined membership status, individuals are either a part of it or not a part of it.”
+
+Developer marketing is all about the developer experience
+Unlike other forms of marketing where there is an overwhelming focus on the top-of-funnel, developer marketing is focused on the relational lifecycle that a developer has with a technology. This is because developers play such a unique role with software. Developers discover, evaluate, advocate internally, and then become the end-user of a solution (here’s a full post on the developer buying journey). This is very different from how other roles interact with software, where the most of the time the end-user of a software isn’t involved in the discovery, evaluation, or advocacy phases.
+
+From a marketing standpoint, developer marketing is responsible for this entire lifecycle spanning from building awareness to driving adoption, then maintaining usage and ultimately retention of the account. This is why we focus so heavily on experience.
+
+Aspects of the developer experience
+The developer experience is comprised of three aspects, which you should use to balance the tactics you are deploying in your strategy.
+
+Developer Content , which includes thought leadership content, technical content like documentation, release notes, or educational content, product marketing content, and how you deliver that content.Product , which includes how developers on board and learn about your product, interact with your product, the end-user experience. It also includes your presence in marketplaces, APIs, and developer tools.Community , which is how developers experience your company in the developer ecosystem like open source, events, hackathons, and online forums.
+
+Creating a developer experience is a massive project, that’s why it’s so important to have a solid strategy that can keep you from diverting all of your effort into a few tactics that don’t result in a long-term win.
+
+Creating a developer marketing strategy
+Developer marketing strategies focus on building developer awareness, product adoption, user retention, developer affinity, and developer education. Developer marketing strategies are measured through KPIs (key performance indicators) around developer tool adoption, developer success, and developer engagement like site visitors, blog reads, and social engagement. Adoption is a great goal because if you can gain adoption, you will have enough data to fix any issues around awareness, usage, and retention. The second component you should think about is your database. Many developer marketers hold the belief that developers don’t fill out forms. I can tell you from personal experience helping to grow a database of over 1.5M developer contacts, that the assumption is wrong or at least not true anymore. Regardless, your database is the most valuable channel that you will develop, and it should be prioritized in your strategy.
+
+Once you have your focus, it’s time to narrow down your audience. The software developer space is huge, it’s really important to know exactly who you are targeting. I suggest starting by focusing in on what type of developer you are interested in attracting, is it a mobile developer or enterprise developer? Then narrow that down by the technologies you want to focus on, like Java, Python, Node, Kubernetes, Spring, MongoDB, etc. Finally, narrow that down again by what they are interested in, cloud-native development or AI/ML? That will get you to a defined audience, for example “enterprise python developers, working on AI/ML projects ...”
+
+The final part of your strategy is to identify your ecosystem, this includes the other technologies you will be integrating with, the marketplaces you will participate in (think VS Code), and the open source projects/communities that will be contributing to your success. By fitting into the existing ecosystem, you can access a pre-established audience who are interested in what you have to say.
+
+When you bring it all together you end up with a strategy that can be articulated something like this:
+
+“Our goal is to build a community of 100K enterprise python developers working on AI/ML projects, with a 25% adoption rate of our ML Kit and 15K installations of our VS Code extension.”
diff --git a/_posts/2020-05-08-improve-developer-email-communication.md b/_posts/2020-05-08-improve-developer-email-communication.md
new file mode 100644
index 0000000000..7c6632ba80
--- /dev/null
+++ b/_posts/2020-05-08-improve-developer-email-communication.md
@@ -0,0 +1,28 @@
+---
+date: 2020-05-08
+author: jw
+title: "Improve email communication with developer audiences"
+description: "Why developer marketing programs should rethink marketing automation and how they email their community"
+categories: [work]
+tags: [Developer Marketing and Programs]
+---
+
+A line drawing by Pablo Picasso | What's with the random art?
+
+A few weeks ago, Evans Data released a new report that found “I’ll targeted messaging as biggest ‘Pet-Peeve’ in developer marketing.” (read the full release ). That shouldn’t come as a big surprise, seeing as most of the marketing email communication sent from vendors isn’t done in a highly-intelligent or intentional way. Some of this can fall on the shoulders of marketers who aren’t technical enough to understand what will be of interest to a developer and some of it might even be the handy work of marketers who are just being lazy. Though this might be true, I don’t think we can blame all of it on miss-guided developer marketing teams. Instead, I think that there is a second culprit, and it goes by the name of ‘automation’.
+
+For years, marketing teams have invested massive amounts into building automated marketing systems that can do the work of entire teams without ever skipping a beat or missing a follow up. Now that we’ve done it, we’re realizing that our marketing utopia is not quite what we wanted. In fact, it’s not what anyone wanted.
+
+Marketing automation started off with good intentions. The goal was to provide a great customer experience, and in many ways, it has accomplished that. Try to imagine a world without shipping confirmations, password reset emails, RSS feeds, or guided on boarding emails. That convenience has come at a price. The price is our relationship with customers, for anyone reading this blog, that’s a relationship with your developer audience.
+
+What’s the solution?
+
+Here’s where it becomes quite difficult. We live in a world where scalability is essential, everything we do in the business world is focused on scalability. But, like I once said on Twitter “The issue with building for scalability is that when you get in trouble, you’re in trouble at scale …”
+
+To be clear, I’m not advocating against the pursuit of scalability or automation. I believe that they have their place in business, and that their place is not to replace a real relationship with your database. Systems act upon the data they are provided; they don’t question the validity of that data or the external environment in which it’s being used. They don’t understand the nuances of human behavior, they simply execute commands when a specific criterion has been met.
+
+I believe that the line between what should and what shouldn’t be automated exists, but it’s not black and white. I think that a lot of our email communication issues can be solved through accurately segmenting databases by region, interest, and relationship type. Then it’s the responsibility of marketers to validate and maintain a high-level of data hygiene in their database. Its’s also their responsibility to exercise self-control when it comes to emailing their database.
+
+Email communication should be evaluated on a per-email basis. When emailing developers who are highly engaged with your community, be more personal. When emailing developers who you just met at a conference, be professional, direct, and don’t pretend that they remember you or come up with a generic sales follow up message. Put a face to your email communication and allow developers to reply back (aka don’t use a no-reply@ email). When emailing globally, be conscious of regional sayings that might not translate to other cultures. Don’t use personal information like a first name, company name, or usage data that you wouldn’t feel comfortable using if you were meeting the person for the first time in real life. Just think of how weird it would be for someone to walk up to you on the street and say “Hi, name. I noticed that you and your team has been reading our blogs on how to migrate x … based on your usage, I thought you might want to attend our upcoming tech talk.” When we read over the list above, most of us would cringe at it, yet it’s exactly what we do in developer marketing all the time and it has to stop.
+
+This post turned into more of a rant than I had intended, for that, I apologize. I hope that it inspires you to level-up your email communication standards and put the relationship with your developer community above your marketing performance metrics. It’s important to remember that a little bit of intentionality goes a really long way in marketing - jw
diff --git a/_posts/2020-05-15-Ep1-Cloud-Chat.md b/_posts/2020-05-15-Ep1-Cloud-Chat.md
new file mode 100644
index 0000000000..6f525c4732
--- /dev/null
+++ b/_posts/2020-05-15-Ep1-Cloud-Chat.md
@@ -0,0 +1,28 @@
+---
+date: 2021-05-15
+author: jw
+title: "Episode 1 of Cloud Chat, Open Source Eclipse Che"
+description: "Open source marketing/community building is demand gen for the enterprise and demand gen for the enterprise is open source marketing/community building."
+categories: [work]
+tags: [Open Source]
+---
+
+A bit of DC street art by, various artists | What's with the random art?
+
+In this episode of Cloud Chat I am joined by Mario Loriedo who is a Sr. Principle Software Engineer at Red Hat. During our conversation we get an update on Eclipse Che, the state of cloud developer environments, and enterprise adoption. Finally, we end our session talking about some of the ins and outs of leading an open source project like Eclipse Che like working with enterprises, building community, and how to keep your open source project growing.
+
+Enjoy, and subscribe to the Eclipse Foundation Cloud Chat Twitch channel!
+
+
+
+
+
+
+
+
+
diff --git a/_posts/2020-05-22-creating-virtual-developer-experience.md b/_posts/2020-05-22-creating-virtual-developer-experience.md
new file mode 100644
index 0000000000..a418d9f846
--- /dev/null
+++ b/_posts/2020-05-22-creating-virtual-developer-experience.md
@@ -0,0 +1,45 @@
+---
+date: 2020-05-22
+author: jw
+title: "The rise of the digital advocacy program"
+description: "Developer marketing and relations are shifting to virtual formats, I believe the future of developer marketing is digital advocacy and relations"
+categories: [work]
+tags: [Developer Marketing]
+---
+
+Bull by, Pablo Picasso | What's with the random art?
+
+
+Last week I published a post title “Creating the virtual developer experience”. After publishing, I realized that the post was really all about a transition that I predict is going to take place with developer advocate and developer relations roles. I’ve decided to update the post to be more focused now that I’m able to articulate my thoughts on the subject with greater clarity. I want to express my apologies if you took the time to read the first post, I jumped the gun on publishing and it wasn’t my best work. Below is a much more thought-out and more importantly practical advice that can be implemented in a way that will drive results. I truly believe that this is a transition that has been in the making for a longtime and if you can get ahead of it, can create a unique position in the market.
+
+Creating a high-quality developer experience, is one of the most difficult aspects of developer marketing and developer relations. As an industry, we’ve been over-dependent on the use of in-person events to drive engagement our developer communities. In-person events are not scalable, are time-intensive, are not capital efficient, and tend to box your message into an eco-chamber. Creating good developer experiences in-person is difficult, and that will increase exponentially online. But now that conferences and Meetups are virtual, there’s an opportunity to re-think the experience that we create for our audience. I believe that this opportunity is the responsibility of developer marketing teams.
+
+Whether we realize it or not, developers have been conditioned by software vendors to expect a certain type of experience in return for joining their community, using their product, or participating in an event. They expect to speak with a subject matter expert vs a sales rep, they expect to receive swag for visiting the booth, they expect to be invited to the developer-only happy hour, and so much more. Most of these expectations are impossible to meet virtually. So how do you make up for it?
+
+In the future, I’m sure the perfect platform will be built. It might be VR or AR, and have all sorts of cool ML aspects. But until that happens, I believe that the future of developer relations and advocacy resides in the hands of a hybrid function called digital advocacy.
+
+Refocusing on digital developer engagement
+Advocating on digital platforms is not a new concept to developer marketing and relation, however, in most developer organizations digital mediums have taken a secondary role to in-person events. Similar to the normal role of developer evangelists/advocates/relations (whatever you want to call it), digital advocacy takes the 1:1/1:few interactions that would normally happen at a conference or on-site with a customer and prioritizes them online. These interactions happen on forum style channels, like Reddit, Hacker news, or Quora, but are not limited to those channels.
+
+Companies that establish a native digital presence, can insert their point of view into the conversation, the same way they would at a conference or Meetup. It will require dedicated resources, spending time on these channels and building trust with communities. Once it’s done, these digital advocates will have daily access to audiences that dwarf those of the biggest developer conferences with none of the overhead.
+
+The digital advocacy stack
+New functions require new tools, or at least combining a stack of existing tools that can accomplish the job. There are a few components that I believe are essential. The first tool is a live stream with the ability to host a live chat. The second component, is a sharable and cloneable development workspace, that can take a snap-shot of the branch the developer is working on and contain an exact replica environment (build and run dependencies, configurations, etc), and have the ability to do peer-programing. The non-essential, but very helpful tools include those of a developer marketer or the support of a digital marketing team to back them up and amplify their efforts.
+
+Live-streaming is a major part of the digital advocacy role. I believe we need to take a lesson from how gamers are hosting live streams on channels like Twitch, YouTube Live, or the new Facebook gaming streams. Their success hinges on their consistency and dependability. They build audiences that are conditioned to expect a live stream at the same time every day of the week. Resulting in daily audiences of 10-250K! Far more than you could ever reach at a conference.
+
+We’re seeing a bit of these live-stream interactions happening during virtual conferences, but I think that moving forward it’s going to play a larger role in the developer marketing strategy. And I’m confident that the teams that invest in building up their audiences before anyone else does, will ultimately win.
+
+The second component is the development workspace. When we look at enterprise development, there are just too many factors when it comes to replicating a project environment for a large audience. Digital advocacy teams need the ability to quickly clone their workspace and share it with their audience so that the audience can get hands-on with what they advocate is working on. Then if an audience member is having an issue, they can jump back into an exact clone of the audience members project and show them exactly what went wrong. There are several online IDEs that allow for this type of workspace sharing, my favorite would be hosted Eclipse Che.
+
+Leveling-up product documentation
+One aspect that will be of increasing importance is good documentation. High-quality and accurate docs are force multipliers for developer advocates and developer marketing teams. There is a ton of developer data that showcases the importance of good product documentation and the frustration that poor documentation creates for developers. As we focus more on virtual experiences, it’s important to make sure that your documentation doesn’t undermine that effort. The better your documentation is, the less time your digital advocates will need to spend on topics that are already ‘well-documented’. Developers lean towards self-servicing their issues; documentation makes that possible. When documentation is out-of-date or non-existent it’s impossible for them to solve their problems and forces them to reach out to your team.
+
+It's important to realize that there are two types of documentation. The documentation that you own on your site, and the documentation that is crowdsourced on channels like Stack Overflow, Quora, and Reddit. Verifying the accuracy of crowdsourced documentation is the job of the digital developer advocate. It’s also their job to proactively answer new questions and hopefully, direct members of the community back to the source of truth, your high-quality proprietary documentation.
+
+Developer marketing’s role in supporting the shift
+Developer marketing is built on programmatic elements. A programmatic element is a marketing effort that doesn’t have a defined start and end date (unlike a campaign). This would include a weekly/monthly developer newsletter, cadenced tech talks, podcasts, or consistent publishing on a blog/social. These elements are designed to build awareness and affinity. The more virtual your developer marketing strategy becomes, the more important it is to embrace and develop programmatic elements.
+
+In addition to maintaining these activities, developer marketing teams need take on the role of amplifying and coordinating the efforts of digital advocates. This looks like augmenting activities with virtual events like a hackathon, boosting the reach of a live-stream with paid ads, or creating a blog post of upcoming stream topics.
+
+The final part is to eliminate one of the biggest issues in developer marketing … vendor or solution bias. The goal of developer marketing isn’t to sell, instead your goal is to help developer solve their problems. Since there is no such thing as a one-size fits all solution, constantly pushing your product is a big turn-off for developers. Your goal should be to provide the best solution, sometimes it’s your product, sometimes it’s an upstream project, and other times it’s another vendor’s product. At the end of the day, adding unbiased value will have a greater ROI than pushing a sub-par solution. The best way to accomplish this is to change how developer marketing teams view their role. Distance your activities from demand gen and focus on developer relations activities. If your goal is to make the developer successful at all cost, you can’t go wrong.
diff --git a/_posts/2020-06-09-knowledge-over-features-dev-marketing.md b/_posts/2020-06-09-knowledge-over-features-dev-marketing.md
new file mode 100644
index 0000000000..02d6e97134
--- /dev/null
+++ b/_posts/2020-06-09-knowledge-over-features-dev-marketing.md
@@ -0,0 +1,18 @@
+---
+date: 2020-06-09
+author: jw
+title: "Knowledge over features, keeping the priorities right"
+description: "Understanding the primary motivators of a developer. Why focusing on knowledge is more important than feature selling."
+categories: [work]
+tags: [Developer Marketing]
+---
+
+Magazine Covers by, Hattie Stewart | What's with the random art?
+
+I love business. It provides a constant challenge. It forces me to stay sharp, to learn, to push myself, to never give up. Through my career, I’ve developed a daily habit of journaling the things that I’m working on, the things I’m struggling to solve, the outcomes that I’m driving, and the lessons that I’m learning. Business is systematic. Once you discover that the foundational concepts are universal, the focus shifts to the tactics and strategies to implement those concepts. This is where we do our best work. The work that stands out and gains recognition. When we see the power of a well-executed tactic, it becomes tempting to shift our focus away from the foundational concept that drove the tactic to be successful. Last week, I was looking through an old journal and came across a page with only three words. “Knowledge over features.”
+
+I’ve spent my career in product marketing. I understand the developer tools that I bring to market, the developer tooling ecosystem, developer workflows, and the communities that power them. This understanding can be powerful. But only if I apply it on top of a foundational concept. Knowledge over features, is a foundational concept in developer marketing.
+
+It’s a reminder to keep the priorities right. Every audience has a motivator. There are primary motivators and secondary motivators. Keeping your job is a primary motivator, receiving a badge for completing an online course is a secondary motivator. The hierarchy of motivators changes from person to person, but there are overlaps and trends within an audience segment. Developers are highly-driven to learn. They work in a role that requires them to stay one step ahead of the rapid evolution we’re seeing in tech.
+
+As a developer marketer, it’s easy to default to feature selling. I get excited when a new feature comes out, and I assume that my audience does as well. Sometimes, that assumption is true. For the most part, it’s not. In fact, I would argue that most of the time developers are so bombarded with new feature announcements that they aren’t even aware that you released something new. And why would they? Developers use your product because it meets their current needs, not because of the future features you included in your product road map. Feature selling is a trap. It’s the easy path, the path that checks all the boxes, but misses the primary motivator. The primary motivator is what drives adoption. This is why a how-to guide or an online tutorial will outperform a feature announce. It’s why a developer newsletter will perform better than release notes. It’s why developers flock to your conference session, but don’t visit your booth.
diff --git a/_posts/2020-09-10-marketing-developer-tools.md b/_posts/2020-09-10-marketing-developer-tools.md
new file mode 100644
index 0000000000..f00ac9adfc
--- /dev/null
+++ b/_posts/2020-09-10-marketing-developer-tools.md
@@ -0,0 +1,40 @@
+---
+date: 2020-09-10
+author: jw
+title: "A few thoughts on PMMing dev tools"
+description: "After a few minutes scrolling through StackShare, I was inspired to write down a few tips for all the PMMs out there slinging dev tools. Here is how to make your product standout, how to get a few early adopters, and a few insights into the dev tools space."
+categories: [work]
+tags: [Product Marketing]
+---
+
+A bit of DC street art by, various artists | What's with the random art?
+
+This week I spent a few minutes scrolling through StackShare checking out new tools which were recently listed. The list seemed endless, a night and day contrast from when I wrote the listings for Codenvy and Eclipse Che in early 2013. The dev tooling space has exploded in recent years and for someone who focuses on dev tools, it’s an exciting time.
+
+Most dev tools are created to improve the workflows of developers and make it easier to build great software. If you keep tabs on the developer ecosystem reports and surveys, you know that most of the market is dominated by a handful of editors, git, CI/CD, build and runtime solutions, frameworks, extensions, and plugins. While I was scrolling through StackShare I couldn’t help but ask a few questions, 1/ If most developers use the same stack, why is the dev tools space expanding at its current rate? 2/ How do you cut through all of the clutter and avoid the pitfall of ambiguity in your product messaging? 3/ How do you build awareness of your solution with developers?
+
+What’s driving the expansion and growth of dev tools?
+
+The obvious reason is supply and demand. As the developer population expands investing into tools that once seemed like an edge case solution can be justified. The second obvious reason is that software has made its way into places that we never would have expected ten years ago (think smart-locks or most of the other smart-home devices) that leverage new languages and frameworks. In theory every time a new language is created another syntax highlighting plugin is released. In fact, just this week I downloaded an IDE that was specific to the software that powers a robot that I’m building with my son, it runs on a simplified version of C++.
+
+I would argue that the not so obvious reason for this expansion is open source …
+
+If you look at a popular project like Kubernetes there is an entire ecosystem of developer tools that have sprung up around the project. It’s incredibly overwhelming, and that’s not even factoring in the tools that have been built around vendor offerings like OpenShift, EKS, AKS, GKS … the list goes on forever. Open Source projects create this foundation that can be used as a springboard for niche solutions and a level of standardization for the enterprise.
+
+This is one of the reasons why dev tool positioning is repetitive at best, and ambiguous at worst. When your tools are built on the same underlying technology, it’s easy for product marketers to fall into the trap of over-adopting the identity of the upstream project. I can’t tell you how many times I’ve looked over the site of a new CI/CD solution just to scratch my head and wonder why they didn’t just call it “Jenkins with a different logo”. Vendors, project leads, and committers invest tons of time and resources into these offerings just to have the features that set them apart completely disregarded in their product marketing materials.
+
+I’ve found that the key to product positioning often begins by working from extreme simplification and brutal honesty towards differentiation. This is really key for product marketers, instead of starting at “a cloud-native IDE for AI/ML” start at “another python IDE built on Eclipse Theia that runs in the cloud and can be customized with plugins”. This forces you to think about the ‘but’ which is what should be the focal point of your product marketing.
+
+In this case, “BUT, unlike VS Code, our IDE is embedded into our platform, has peer-programming, and has OBS-mode that auto blurs sensitive data so you can live-stream all your work directly onto Twitch”. From this point you can easily see the theme that begins to stand out, this IDE has a social focus and is specific to a platform. Your positioning will now change from “A-IDE, a cloud-native workspace for platform.io” to “A-IDE, social coding for platform.io”. This positioning is much more compelling and identifies with the audience that you are targeting. Note, that I didn’t add anything about AI/ML or cloud-native, this is because we’re assuming that the type of development is implied by the platform you are building on. We’re hyper-focused on the aspects that matter, everything else can be called out later.
+
+You built it and positioned it, why don’t they use it?
+
+Going back to the original questions that sparked this post, in an ecosystem that is so crowded, how do you build awareness of your tool? This is not a simple question to answer, in fact it’s probably the one thing that every marketer (no matter the industry) thinks about daily … I know I do. Luckily, there are a few things that you can do to help your chances of getting noticed, which is the first step. To keep things simple, let’s continue to use the example above of A-IDE. We have a defined product with a defined set of users (this is fairly easy for our example since they have to use platform.io for AI/ML development and be interested in live-streaming on Twitch).
+
+If you’re not technical, think of a dev tool like any other tool and ask yourself what you would care about if you had to go to a hardware shop to buy one. If you’re like me, you want the most optimal tool for the job. Things like price, color, name, and brand don’t matter, all I care about is if it will get the job done in a way where I exert as little effort as possible. Developers are the same way I would even argue that they are way more obsessed with this than you are about buying a hammer. Being driven by laziness isn’t frowned upon by developers, after all they created the copy/paste button. This is your first stop for building awareness, your goal should be to make sure that developers know that your tool makes it easier and faster to accomplish their desired outcome.
+
+As product marketers, we tend to focus on technical problems. For A-IDE, the integration with platform.io might eliminate a complex self-service integration that is notorious for security vulnerabilities. This improvement should be quantified and should be surfaced early in your marketing materials. But, the real benefit for developers is that they can live-code without worry and forget the pain of scrubbing their videos of sensitive information. Too many products focus on easing the burden of configuration, however, that burden doesn’t persist when once they’ve completed it. Compare this to editing videos on a daily or weekly basis, and you have a compelling reason to try your product.
+
+This is where product marketing for developer tools becomes really fun. Developers tend to seek guidance from their community when making a decision about a tool, so as long as it’s true, you have a good chance of building awareness quickly. I’ve found that companies that share really good tools with developer communities on Reddit, Twitter, HN, etc. can often times see their solutions take off overnight.
+
+I hope that this post provides you with a few things to think about next time you are planning on bringing a tool to market. If you have questions, hit me up on twitter.
diff --git a/_posts/2020-10-30-developer-marketing-database.md b/_posts/2020-10-30-developer-marketing-database.md
new file mode 100644
index 0000000000..9779d9c116
--- /dev/null
+++ b/_posts/2020-10-30-developer-marketing-database.md
@@ -0,0 +1,31 @@
+---
+date: 2020-10-30
+author: jw
+title: "The divisive developer database"
+description: "Few topics raise tensions in a marketing org like bringing up the developer database. Sales teams need leads to follow up on and marketing needs to hit numbers to satisfy the sales team’s quota. For developer marketing teams, that often times means living outside of the good graces of the broader revenue org."
+categories: [work, developer marekting]
+tags: [Developer programs]
+---
+
+A piece from Raoul De Keyser , an artist I recently discovered | What's with the random art?
+
+
+Few topics raise tensions in a marketing org like bringing up the developer database. Sales teams need leads to follow up on and marketing needs to hit numbers to satisfy the sales team’s quota. For developer marketing teams, that often times means living outside of the good graces of the broader revenue org. In this post I’m going to talk about a few ways to build an internal understanding of the importance of a dedicated developer database and why protecting the developer database is key.
+
+Before we dive into it, if you don’t understand the developer buying journey, I would encourage you to check out the three-part series that I wrote on the developer buying journey last year. The series covers the developer buying journey, the role of open source and developer communities, and finally developers and BANT/the sales process. If you are new to dev marketing, it’s a great place to start.
+
+Why building a developer database is important
+
+
+It’s important to understand that enterprise sales is comprised of two main personas, decision makers and end users. When you look at how decision makers interact with a technical sales cycle, they tend to assume a cyclical relationship. They identify a need, they evaluate solutions, they make a purchasing decision, and after a predetermined amount of time they either renew that agreement or reevaluate their options. Developers on the other hand develop a more linear relationship with a product. As they use the product, their knowledge of the product increases, as does their knowledge of how that product or solution integrates with other solutions. For a developer, switching products can cost much more than the price of the product, it means losing major learnings that took time to build.
+
+This is why the role of developer marketing can have such an incredible impact on customer retention and expansion, and why developer marketing teams focus so heavily on establishing programmatic elements vs marketing campaigns. For developer marketers, building a database that is engaged and healthy is the main way to ensure that the end users of your products are continually increasing their knowledge and affinity for your solution. This is in contrast to demand gen, growth, and field marketing objectives where the goal is to push contacts into a buying process. If the contact has already bought your product, they are no longer valuable unless you have another product to sell. To developers, most of the time this type of interaction is not appreciated. Developers evaluate products based on challenges and needs, if they don’t have a need for the product or are facing a challenge that the product can solve, pushing these solutions does more damage than good. Timing this process is almost impossible, that’s why developer marketing programs are so valuable. I find that it’s in the best interest for most companies to view developer marketing as a customer success function and not a demand gen function.
+
+Creating organizational alignment
+
+
+Developer marketing teams tend to be viewed as an enigma in most companies. They aren’t developers but they are technical and the good ones can code, they aren’t advocates but they behave like them, and they aren’t marketers but they use all of the marketing team’s tools. To make things even more complicated, some of the most successful dev marketing teams report through product teams and in some cases even have products that they manage. These differences are a fast track to organizational misalignments and misunderstanding. Though I’ve never achieved 100% internal alignment, I have found several ways to build a common understanding and appreciation.
+
+The most important thing is to creating alignment, is defining who developers are. This includes job titles, levels, and technologies used. All too often companies group all technical roles into a ‘developer’ segment. The issue with this is that though all developers are technical, not all technical roles are developers. There are technical roles that can meet sales qualification criteria and who actively participate in the buying cycle. You see this a lot with IT roles, which is why tensions can build quickly. Generally, speaking your developer database should not contain contacts that would qualify as a lead in a sales funnel. If it does, it means that your targeting is either too broad or your developer titles might be too senior. The other thing that creates tension is if the targeting criteria is too narrow and developer contacts are being sent to sales and marketing as a qualified lead. Finding the perfect balance takes time, but the effort is well worth the wait. It’s important to meet regularly with sales and marketing to refine your process, and keep an eye on the contacts who are being passed off as a lead. Unsubscribe and click-through-rates are a valuable early indicator of how your segmentation is working.
+
+The second way to create alignment is to educate and advocate internally about the impact that developers play in the buying process. Most people understand that developers don’t have budget to spend or the authority to make a purchasing decision, but they don’t understand the influence that developers have on a sale. It’s important to build an understanding of the impact that poorly targeted or overly aggressive marketing and sales campaigns can have a developer’s affinity towards your company. With so many options on the market, developers can be picky about which solutions they use, and believe me, they are ...
diff --git a/_posts/2021-02-19-open-source-enterprise-growth.md b/_posts/2021-02-19-open-source-enterprise-growth.md
new file mode 100644
index 0000000000..d20266eaa1
--- /dev/null
+++ b/_posts/2021-02-19-open-source-enterprise-growth.md
@@ -0,0 +1,23 @@
+---
+date: 2021-02-19
+author: jw
+title: "The jointly exhaustive relationship between open source and enterprise growth"
+description: "Open source marketing/community building is demand gen for the enterprise and demand gen for the enterprise is open source marketing/community building."
+categories: [work]
+tags: [Open Source]
+---
+
+A bit of DC street art by, various artists | What's with the random art?
+
+It’s been a few months since I last published a post on developer marketing. I’ve been busy with the holidays, a new role at AWS, not to mention life beginning to slowly return to normal (kids going back to school, people working vs doom scrolling all day, trying to burn that quarantine fifteen ... you get it). I’ve also been mentally wrestling with a few changes that I’ve observed taking place in the developer tools space. We’ve heard it said many times that COVID accelerated key business trends like cloud adoption, remote working, and online learning. When the dust settles, I think that we’re going to realize that a lot more has changed, in fact it’s hard to believe that anything was completely un-impacted. Developer marketing, open source community building, and technical product marketing for dev tools is no exception. I think an argument could easily be made that our space was one of the more impacted areas and that the transitions we’ve seen from COVID are going to increase the scope of our space. In this post, I want to share a trend that I’m seeing develop between open source and the enterprise.
+
+Last year I wrote a lot about the open source business model and developer marketing strategies, but what I didn’t hit on was the somewhat (maybe extremely?) symbiotic relationship between the two of them. For context, this post was inspired by two recent conversations with founders bringing products to market with an open source strategy. Our conversations center around how to maintain a balanced focus on both and ensure that both the project and the product are jointly successful. I find that this is always a point of tension, but it doesn’t need to be that way. Open source feels complex, but in reality, it’s not. Companies have been doing this successfully for decades now, but never at the level that we see it today. Open source projects have become dependent on the enterprise to fund their existence and the enterprise has become dependent on open source to champion industry standards and lower the barriers and cost of building new software. When we look at the growth of these joint strategies, the relationship is nothing less than jointly exhaustive. I can’t emphasize this enough, open source marketing/community building is demand gen for the enterprise, and demand gen for the enterprise is open source marketing/community building .
+
+Open source has been skyrocketing in popularity lately, which amplifies the trend above due to competition and crowding in the space. Just a few years ago it wasn’t normal for a startup to open source their codebase, now it’s hard to find one in our space that hasn’t. Why? I think that there are a few reasons for this. Some are completely legitimate and others I can’t see as anything more than a corporate virtue signal. Let’s start by looking at why companies are open sourcing in regards to growth.
+
+I’ve found that there are three main reasons, 1) awareness with developers (a.k.a. the end user). This is generally well intentioned, open source foundations are trusted by developers and developers flock to open source communities to find innovation and learn. By open sourcing your product you gain access to all of those developers who if interested might even help you advance your project. This is the open source world at its best. 2) Pursuing an industry standard. If your goal is to build an ecosystem around your project or you can benefit from the industry as a whole adopting your project, open source is the way to go. This strategy allows you to easily partner with other companies and tie your growth to their growth. This is the win:win open source utopia that companies often envision when exploring open source as a strategy ... that is until someone bases a competitive solution on the project you pioneered. This is both the best and in a few cases the worst of the open source world. 3) Nothing but optics. Every now and then I talk to someone who open sourced a product for all the wrong reasons. They wanted to attract and retain employees, they wanted to be associated with a popular foundation, or they wanted to land a big deal that had open source in the criteria. This almost never works and is one of the reasons that there are so many dead projects out there. Open source is about the community and optics don’t build community ... it’s not authentic.
+
+If your reasoning is based on point 1 or 2, there is a very good chance that open sourcing will positively benefit the growth of your company. But, you can’t just open source and walk away. Remember the statement that I made above, open source marketing/community building is demand gen for the enterprise and demand gen for the enterprise is open source marketing/community building . The strategy only works when it has a healthy open source community to build upon. This is where the enterprise becomes really important. The enterprise has resources and open source projects need resources (developers, audiences, customers, MONEY). If you look at any of the top open source projects, the main contributors are developers who are employed by the enterprise for the purpose of contributing to these projects (if you’re curious about how they stack up, here’s the rankings ). This gives the project a healthy baseline, meaning that it’s not growing stagnant. These enterprises then advocate for the project, which attracts individual contributors, forming a community. The enterprise also sponsor the foundation where the project lives which funds the things we never talk about but make a big difference, like project branding, an advisory board, community events, and foundation management.
+
+Healthy projects have thriving communities and communities create awareness. Awareness of the upstream project creates awareness of the downstream product. And, vice versa product growth puts attention on the project, the more customers your product has the more invested they will be in the health of the upstream project.
+
diff --git a/_sass/base.scss b/_sass/base.scss
index 3a97b44a0a..7fe6a95b12 100644
--- a/_sass/base.scss
+++ b/_sass/base.scss
@@ -18,7 +18,8 @@ html, body, h1, h2, h3, h4, h5, h6, p, ul, ol, li, img {
/*- Base color -*/
-$main-color: #008A3C;
+$main-color: #27e87d;
+$nav-background: #000000;
$background-color: #FDFDFD;
$text-color: #222222;
diff --git a/_sass/custom.scss b/_sass/custom.scss
index 3c6ab42907..ddf2aad2c9 100644
--- a/_sass/custom.scss
+++ b/_sass/custom.scss
@@ -1,3 +1,25 @@
/*- Custom style -*/
-// -- Put custom style under this point -- //
\ No newline at end of file
+// -- Put custom style under this point -- //
+
+
+
+
+ #posts li {
+ padding: 2rem;
+ box-shadow: 0px 1px 2px rgba(46, 41, 51, 0.22), 0px 2px 4px rgba(71, 63, 79, 0.28);
+ background: #ffffff;
+ border-radius: 4px;
+ border: 0;
+ margin-bottom: 1.5rem;
+ }
+
+ span.heroart {
+ font-size: 0.7em;
+ color: #9e9e9e;
+ }
+
+ li p span.heroart {
+ display: none;
+
+ }
\ No newline at end of file
diff --git a/_sass/layout.scss b/_sass/layout.scss
index 3f02a2445a..e3964af531 100644
--- a/_sass/layout.scss
+++ b/_sass/layout.scss
@@ -165,14 +165,7 @@ html, body {
}
}
-.post+.post:before {
- display: block;
- content: '';
- width: 5rem;
- height: 1px;
- margin: 23px auto;
- background-color: lighten($text-color, 70%);
- }
+
.by-line {
display: block;
diff --git a/_sass/mixin.scss b/_sass/mixin.scss
index cd13e896a8..7e9602ffd5 100644
--- a/_sass/mixin.scss
+++ b/_sass/mixin.scss
@@ -25,7 +25,7 @@
@mixin nav-position($position) {
width: 14rem;
position: fixed;
- background-color: $main-color;
+ background-color: $nav-background;
top: 0;
bottom: 0;
#{$position}: -14rem;
diff --git a/_sass/typography.scss b/_sass/typography.scss
index 71321a9d8a..c4ea80a7e4 100644
--- a/_sass/typography.scss
+++ b/_sass/typography.scss
@@ -4,34 +4,46 @@
//
body {
- font-family: 'Source Sans Pro', sans-serif;
- letter-spacing: 0.01em;
+ letter-spacing: 0.02em;
}
+
/*- Typography for medium and small screen, based on 16px font-size -*/
p, ul, ol {
font-size: 1em; /* 16px */
line-height: 1.5em; /* 24px/16px */
margin-bottom: 1.5em; /* 24px/16px */
+ font-family: 'Muli', sans-serif;
}
h1 {
font-size: 2.25em; /* 36px/16px */
line-height: 1.3333em; /* 48px/36px */
padding: 0.33335em 0; /* 12px/36px * 2 (Use padding instead of margin to maintain proximity with paragraph) */
+ font-family: 'Muli', sans-serif;
}
h2 {
font-size: 1.5em; /* 24px/16px */
line-height: 1em; /* 24px/24px */
padding: 1em 0 0 0; /* 12px/24px * 2, only top (Use padding instead of margin to maintain proximity with paragwithph) */
+ font-family: 'Muli', sans-serif;
}
-h3, h4, h5, h6 {
+h3 {
font-size: 1.125em; /* 18px/16px */
line-height: 1.3334em; /* 24px/18px */
padding: 0.66667em 0; /* 12px/18px * 2 (Use padding instead of margin to maintain proximity with paragraph) */
+ font-family: 'Muli', sans-serif;
+}
+
+h4, h5, h6 {
+ font-size: 1em;
+ line-height: 1.3334em; /* 24px/18px */
+ padding: 0.66667em 0; /* 12px/18px * 2 (Use padding instead of margin to maintain proximity with paragraph) */
+ font-family: 'Muli', sans-serif;
+ font-weight: 300;
}
blockquote {
@@ -43,6 +55,7 @@ blockquote {
border-radius: 4px;
background-color: darken($background-color, 5%);
padding: 0 1.5em; /* 24px/18px */
+ font-family: 'Crimson Text', serif;
p, ul, ol {
padding: 1.5em 0; /* 24px/18px */
}
@@ -56,24 +69,36 @@ p, ul, ol {
font-size: 1em; /* 18px */
line-height: 1.3334em; /* 24px/18px */
margin-bottom: 1.3334em; /* 24px/18px */
+ font-family: 'Muli', sans-serif;
}
h1 {
font-size: 2.6667em; /* 48px/18px */
line-height: 1em; /* 48px/48px */
padding: 0.25em 0; /* 12px/48px * 2 (Use padding instead of margin to maintain proximity with paragraph) */
+ font-family: 'Muli', sans-serif;
}
h2 {
font-size: 2em; /* 36px/18px */
line-height: 1.3334em; /* 48px/36px */
padding: 0.66667em 0 0 0; /* 12px/36px * 2, pnly top (Use padding instead of margin to maintain proximity with paragraph) */
+ font-family: 'Muli', sans-serif;
}
-h3, h4, h5, h6 {
+h3 {
font-size: 1.3334em; /* 24px/18px */
line-height: 1em; /* 24px/24px */
padding: 0.5em 0; /* 12px/24px * 2 (Use padding instead of margin to maintain proximity with paragraph) */
+ font-family: 'Muli', sans-serif;
+}
+
+h4, h5, h6 {
+ font-size: 1em; /* 24px/18px */
+ line-height: 1em; /* 24px/24px */
+ padding: 0.5em 0; /* 12px/24px * 2 (Use padding instead of margin to maintain proximity with paragraph) */
+ font-family: 'Muli', sans-serif;
+ font-weight: 300;
}
blockquote {
@@ -85,6 +110,7 @@ blockquote {
border-radius: 4px;
background-color: darken($background-color, 5%);
padding: 0 1.33334em; /* 24px/18px */
+ font-family: 'Muli', sans-serif;
p, ul, ol {
padding: 1.33334em 0; /* 24px/18px */
}
diff --git a/about.md b/about.md
index 314dc6a17f..4577c75964 100644
--- a/about.md
+++ b/about.md
@@ -1,21 +1,47 @@
---
layout: page
-title: About Emerald
+title: about me
+description: "Jesse Williams, specializes in developer marketing and relations, open source community building, and bringing developer-facing technologies to market."
---
-## About
-Emerald is a minimal theme created for Jekyll. The main purpose of Emerald is to provide a clear theme for those who want a blog ready to use, focused on the content and mobile-first.
+## about me
+Welcome, my name is Jesse Williams.
-For further details on Emerald, please visit the [repository on Github](https://github.com/KingFelix/emerald/).
+This is where I house my thoughts on topics that interest me including product marketing, open sources strategies, developer marketing, and anything else that catches my attention. The opinions that you will find in my posts are my own, they do not represent the views of my employer (AWS) and are taken directly from my current views on life, which I expect will change as I grow and experience more. Life is a journey, you can follow mine or ignore it ... trolling is unappreciated.
-
+All is grace,
+Jesse
-### Setup
-Emerald may be installed by simply downloading the .zip folder from the [repository on Github](https://github.com/KingFelix/emerald/archive/master.zip).
+
-After extracting the content from the folder into the selected directory, you can type ``jekyll serve`` from the terminal, than open your browser to ``0.0.0.0:4000/emerald/`` and you will find it there.
-Additionally it is possible to fork the repository and use Github Pages as hosting. By following this way it will be enough to change the ``baseurl`` value into the ``_config.yml`` file, with the directory name of your project (for example /blog) or simply with a "/" (slash) if you want install Emerald in the root.
+## professional bio
-Last but not least: the [Jekyll documentation](http://jekyllrb.com) is the best starting point!
+Jesse Williams specializes in leading product marketing for developer tools. He has a deep understanding of developer workflows, how to position technical products in competitive markets, and how to enable sellers to confidently bring developer solutions to IT decision makers. Jesse currently leads Product Marketing for the AWS DevTools potfolio (CDK, IDEs, IDE Toolkits, SDKs, IaC.) Prior to AWS, Jesse led the lifecycle marketing team for Red Hat Developer, a community of over 1.5 million independent software developers. Jesse got his start in developer marketing while leading the marketing efforts for Codenvy and open source Eclipse Che.
-Enjoy!
\ No newline at end of file
+Outside of work, he is involved with the Eclipse Cloud Development Tools Working Group, where he hosts Cloud Chats, a Twitch series focused on open source leadership and strategy, and serves as a board advisor for Stanza, an open source log agent that’s part of the CNCF’s OpenTelemetry project.
+
+Jesse resides in Alexandria, VA with his wife and three kids.
+
+accomplishments
+
+- Founding member of YouCaring (Acq. GoFundMe)
+
+- Head of demand gen and marketing ops for Codenvy (Acq. Red Hat)
+
+- Lifecycle marketing lead, Red Hat Developer (Acq. IBM)
+
+
+projects
+- Played key role: ExecVision to close $5.4M growth round led by Edison Partners
+
+- Played key role: Mindbox Studios expansion into Redding, CA
+
+- Marketing lead: Open source Eclipse Che reaches +5,500 GitHub stars
+
+- Consulting: DroneDeploy, SkyCatch, HelioCampus, Spiritus Solutions
+
+
+## what's with the random art
+I'm sure that after looking around my site, many of you are wondering "What's with the random art?"
+
+It's difficult to find good art these days. Maybe it's because the appreciation for art is dieing or maybe it's because we're constantly bombarded with cheap knock-offs? Either way, I love art and hope that my appreciation for it gets transfered to those who visit my site. I've included links to learn more about the artists under each image. Sorry in advance for all the Picasso, I've felt a connection to his work and hope to own a few original pieces in the future.
diff --git a/img/Keyser-site-art.png b/img/Keyser-site-art.png
new file mode 100644
index 0000000000..7db85e4535
Binary files /dev/null and b/img/Keyser-site-art.png differ
diff --git a/img/Zhu_Jinshi_site_art.png b/img/Zhu_Jinshi_site_art.png
new file mode 100644
index 0000000000..c25e4ed439
Binary files /dev/null and b/img/Zhu_Jinshi_site_art.png differ
diff --git a/img/banksy-site-art.png b/img/banksy-site-art.png
new file mode 100644
index 0000000000..2ffdddaa8e
Binary files /dev/null and b/img/banksy-site-art.png differ
diff --git a/img/codeproject.png b/img/codeproject.png
new file mode 100644
index 0000000000..66a180a465
Binary files /dev/null and b/img/codeproject.png differ
diff --git a/img/davis-site-art.png b/img/davis-site-art.png
new file mode 100644
index 0000000000..25e4d760be
Binary files /dev/null and b/img/davis-site-art.png differ
diff --git a/img/dcstreet-site-art.png b/img/dcstreet-site-art.png
new file mode 100644
index 0000000000..e4148b3e60
Binary files /dev/null and b/img/dcstreet-site-art.png differ
diff --git a/img/devto.png b/img/devto.png
new file mode 100644
index 0000000000..3e92a88f22
Binary files /dev/null and b/img/devto.png differ
diff --git a/img/family.png b/img/family.png
new file mode 100644
index 0000000000..465156af95
Binary files /dev/null and b/img/family.png differ
diff --git a/img/hashnode.png b/img/hashnode.png
new file mode 100644
index 0000000000..8de1803ecb
Binary files /dev/null and b/img/hashnode.png differ
diff --git a/img/jesse-williams-logo.png b/img/jesse-williams-logo.png
new file mode 100644
index 0000000000..93fd062f79
Binary files /dev/null and b/img/jesse-williams-logo.png differ
diff --git a/img/jrw.png b/img/jrw.png
new file mode 100644
index 0000000000..bf6fd7f707
Binary files /dev/null and b/img/jrw.png differ
diff --git a/img/lobsters.png b/img/lobsters.png
new file mode 100644
index 0000000000..38aefeeaf5
Binary files /dev/null and b/img/lobsters.png differ
diff --git a/img/picasso-site-art.png b/img/picasso-site-art.png
new file mode 100644
index 0000000000..f138dfa7a6
Binary files /dev/null and b/img/picasso-site-art.png differ
diff --git a/img/picasso_bulls.jpg b/img/picasso_bulls.jpg
new file mode 100644
index 0000000000..63cb44bf47
Binary files /dev/null and b/img/picasso_bulls.jpg differ
diff --git a/img/site-art-hattie-stewart.png b/img/site-art-hattie-stewart.png
new file mode 100644
index 0000000000..1c53af22da
Binary files /dev/null and b/img/site-art-hattie-stewart.png differ
diff --git a/img/siteart-ed-moses.png b/img/siteart-ed-moses.png
new file mode 100644
index 0000000000..13f3eaa1c6
Binary files /dev/null and b/img/siteart-ed-moses.png differ
diff --git a/img/siteart-joan-miro.png b/img/siteart-joan-miro.png
new file mode 100644
index 0000000000..fe589f3f32
Binary files /dev/null and b/img/siteart-joan-miro.png differ
diff --git a/img/siteart-matisse.png b/img/siteart-matisse.png
new file mode 100644
index 0000000000..112c64f092
Binary files /dev/null and b/img/siteart-matisse.png differ
diff --git a/img/siteart-rothko.png b/img/siteart-rothko.png
new file mode 100644
index 0000000000..24ac397d31
Binary files /dev/null and b/img/siteart-rothko.png differ
diff --git a/img/slashdot.png b/img/slashdot.png
new file mode 100644
index 0000000000..203c1ae555
Binary files /dev/null and b/img/slashdot.png differ
diff --git a/index.html b/index.html
index c589aa4bf9..3899fbbb06 100644
--- a/index.html
+++ b/index.html
@@ -2,14 +2,26 @@
layout: default
---
+
{% for post in paginator.posts %}
+
+
-
+
+ {{post.tags}}
+
+
+
+
{{ post.date | date_to_string }}
- {{ post.content | strip_html | truncatewords:50 }}
+ {{ post.description }}
{% endfor %}
diff --git a/readme.md b/readme.md
index 969b7ba91c..c3904ada01 100644
--- a/readme.md
+++ b/readme.md
@@ -1,4 +1,14 @@
-## About
+## About
+This is where I house my thoughts on topics that interest me including: Startups, Marketing, Technology, Finance & anything else that catches my attention. The opinions that you will find in my posts are my own, they are taken directly from my current views on life, which I expect will change as I grow and experience more. Life is a journey, you can follow mine or ignore it … trolling is unappreciated.
+
+All is grace, Jesse
+
+## Make a PR
+Think you have an article that would be interesting to my audience? Find a typo that you can't get over? I've included a Gitpod link below that makes PRs very easy and some information about how to use my sites Jekyll theme.
+
+[](https://gitpod.io/#https://github.com/KingFelix/emerald)
+
+## About the theme
Emerald is a minimal theme created for Jekyll. The main purpose of Emerald is to provide a clear theme for those who want a blog ready to use, focused on the content and mobile-first.
@@ -50,3 +60,38 @@ Last but not least: the [Jekyll documentation](http://jekyllrb.com) is the best
## License
Emerald is released under [MIT License](license.md).
+
+### Styles
+This is a CSS example:
+{% highlight css linenos %}
+
+body {
+ background-color: #fff;
+ }
+
+h1 {
+ color: #ffaa33;
+ font-size: 1.5em;
+ }
+
+{% endhighlight %}
+
+And this is a HTML example, with a linenumber:
+{% highlight html linenos %}
+
+
+ Example
+
+
+{% endhighlight %}
+
+Last, a Ruby example:
+{% highlight ruby linenos %}
+
+def hello
+ puts "Hello World!"
+end
+
+{% endhighlight %}
+
+
diff --git a/sitemap.xml b/sitemap.xml
new file mode 100644
index 0000000000..eb5b9a3693
--- /dev/null
+++ b/sitemap.xml
@@ -0,0 +1,56 @@
+---
+layout: null
+sitemap:
+ exclude: 'yes'
+---
+
+
+ {% for post in site.posts %}
+ {% unless post.published == false %}
+
+ {{ site.url }}{{ post.url }}
+ {% if post.sitemap.lastmod %}
+ {{ post.sitemap.lastmod | date: "%Y-%m-%d" }}
+ {% elsif post.date %}
+ {{ post.date | date_to_xmlschema }}
+ {% else %}
+ {{ site.time | date_to_xmlschema }}
+ {% endif %}
+ {% if post.sitemap.changefreq %}
+ {{ post.sitemap.changefreq }}
+ {% else %}
+ monthly
+ {% endif %}
+ {% if post.sitemap.priority %}
+ {{ post.sitemap.priority }}
+ {% else %}
+ 0.5
+ {% endif %}
+
+ {% endunless %}
+ {% endfor %}
+ {% for page in site.pages %}
+ {% unless page.sitemap.exclude == "yes" or page.name == "feed.xml" %}
+
+ {{ site.url }}{{ page.url | remove: "index.html" }}
+ {% if page.sitemap.lastmod %}
+ {{ page.sitemap.lastmod | date: "%Y-%m-%d" }}
+ {% elsif page.date %}
+ {{ page.date | date_to_xmlschema }}
+ {% else %}
+ {{ site.time | date_to_xmlschema }}
+ {% endif %}
+ {% if page.sitemap.changefreq %}
+ {{ page.sitemap.changefreq }}
+ {% else %}
+ monthly
+ {% endif %}
+ {% if page.sitemap.priority %}
+ {{ page.sitemap.priority }}
+ {% else %}
+ 0.3
+ {% endif %}
+
+ {% endunless %}
+ {% endfor %}
+
\ No newline at end of file