.NET Summer Hackfest Round One Recap

We kicked off the .NET Summer Hackfest with the goal of porting our existing Keen IO .NET SDK to .NET Standard 2.0, and I’m excited to say that we just about accomplished our goal! Our entire SDK, unit tests, and CI builds have been converted to run cross-platform on .NET Standard. All there is left to do is a little bit of clean up and some documentation updates that are in the works.

There are some big benefits to adopting .NET Standard 2.0, here are some highlights:

  • The Keen .NET SDK can be used with .NET Core, which means it can be included in apps deployed on Linux, Mac OS, and cool stuff like Raspberry Pi
  • Mono-based projects will be officially supported in their next version, which may or may not have worked before, but now it’ll for sure work. This also means Unity can use the new .NET Standard library!
  • We can multi-target and to reduce the size of the codebase and complexity
  • All the Xamarin variations will be supported in their next version

Everyone who contributed during this event was open, collaborative, and ready to learn and teach. We were very happy to be a part of this and look forward to future ‘hackfests’.

I’d like to give a special shoutout to and thank our community contributors that jumped in on the project: Doni Ivanov & Tarun Pothulapati

I’d also like to thank Justin & Brian from our team, Jon & Immo from Microsoft, & Microsoft MVP Oren for all their work and support during our two week sprint.

Announcing: .NET Summer Hackfest

Keen IO is excited to be the first featured project in the first ever .NET Summer Hackfest! It’s coming up next Monday, July 24 and wraps up Friday, August 4th.

.NET Summer Hackfest is a six week community run open source hackfest. Teams are get together to contribute to open source projects for a two week session. It’s an opportunity to get involved in open source.

The main project is to work together to port our .NET SDK to .NET Standard 2.0. But we will also list various SDK improvements and example code projects if porting to .NET Standard 2.0 doesn’t sound like your cup of tea. We have projects and issues outlined in our GitHub repo along with contribution guidelines and information on how to get started. There’s also a slack channel, #dotnetsummer, in our Community Slack Chat (http://keen.chat) and we’ll be there to hang out and talk shop the whole two weeks.

Check out the .NET Foundation’s announcement about our project!

There will be a kickoff post on the July 24th, and we’ll update this post with that info.

FYI* Contributors don’t need to commit to working the whole two weeks. We are designing this to be collaborative and hope that it’s educational and useful to anyone who gets involved. Please feel free to reach out on slack or twitter (@keen_io) with questions or suggestions.

Here’s a video walking through getting started setting up your .NET dev environment and contributing to the project: https://vimeo.com/226976574

Happy Hacking.

Keen IO .NET SDK on GitHub


What’s up in OSS in 2017

We are very excited here at Keen IO to announce the fourth annual Open Source Show and Tell! The event is Friday, June 9th from 1pm to 5pm in downtown San Francisco. Grab a ticket here.

We come together to learn and share about open source software and what people are working on. The event allows members of the community to submit talks about anything open source.

This year we are partnering with Google Cloud (hosted at the Google Launchpad in downtown SF), GitHub, and Microsoft + Open Source. If you’re curious, just getting into open source, or have been a community member for a long time, please come and participate. All are welcome.

Here’s some of the open community talks from 2015 and 2016:

Abstracts from 2015

Heather Rivers talking at the 2015 OSSAT

Abstracts from 2016

Submit your own talk!

The free 4-hour event consists of multiple speakers and 20-minute talks on all sorts of interesting open source topics and technologies. And of course, there’s social hour afterwards.

Grab a ticket and come learn what’s going on in OSS in 2017.

Feel free to reach out to me with questions. :D

hack.guides() Tutorial Contest!

Are you obsessed with building Dashboards? We are excited to sponsor a $500 prize for the best guide using Keen IO to power dashboards in their apps.

Over next six weeks, you can submit tutorials and collaborate with hack.guides() developer community on the best practices, hacks, and tricks using keen, RethinkDB, and other partners in production.


Submit your post here and the share your posts with us on Twitter to spread the word.

OSSAT Recap!

The 3rd annual Open Source Show and Tell is a wrap, and we had such a good time.

We kicked off the day with Mathias wowed us with the power of F#, .NET, and Visual Studio Code via some live coding, the demo gods were friendly on this day.

Ian Eyeberg gave us a thorough introduction with some good #jokes on the Emerging Unikernel Ecosystem.

Francesc, of Google fame, talked through a brief history of Open Source with some interesting behind the scenes details and an overview of how Google supports and uses OSS.

Nadia gave a stellar talk on the importance of creating a contributing template and shared this super useful guide for all to use.

There were lots of other excellent talks about things like the first ever open source voting platform and hacking PostgressSQL do to advanced data parsing, which is pretty handy if you don’t want to hang out in RegEx land all the time. Check out the rest of the topics here.

Big thanks to Beth and Microsoft for co-organizing and hosting. Stay tuned; we will be posting videos of the talks shortly.

Today we're excited to announce that we have an integration with Reekoh!

Reekoh is a new IoT Platform-as-a-Service, with a unique and powerful “app store” model for customization. There are many IoT platforms entering the market, but Reekoh takes extensibility to a new level with Plugins.

Plugins are the way that users can build the custom features and data flows they need for their specific IoT application and deployments. Plugins allow users to easily and quickly build integrations to communication gateways, storage options, cloud service connectors and platforms, as well as other development stack tools such as loggers and exception handlers.

So how does Keen IO and Reekoh work together?

The Keen IO Connector is one of the first Plugins released to the Reekoh Plugin Store, because powerful visualization and analysis of device data is a core component to IoT solutions. Using the Keen IO plugin for Reekoh means it only takes minutes to configure your integration.

Reekoh’s approach gives developers a powerful IoTbackend platform that can make working with large numbers of cross-vendor devices, protocols and systems a seamless experience, and scalable from prototype to enterprise deployment.

Check out the integration guide to get startedLet us know what you thinkand happy hacking.

Analytics in 60 Seconds

I was talking with a co-worker, Eric, about how quickly we might be able to get totally custom analytics onto a page.

He told me he thought we could do it in under a minute. I know that I can’t type fast enough to actually get it done in that amount of time, but Eric was pretty confident… Challenge accepted!


Anyone else up for the challenge? Get a metric on a page in less than 60 seconds or challenge yourself by trying this with another API. We used Screeny for the screen capture and Nice Timer for the countdown, but there are plenty of tools out there if you don’t like those.

Definitely send us your videos on Slack or share on Twitter#analyticsin60seconds

Visualize activity at your next event with lasers. Lasers!

A little while back we sat down with the good people over at Particle and figured out a way we could show off how to use Keen IO and Particle at an in person event called DevGuild. Particle has some seriously cool hardware and software tools for prototyping, scaling, and manage IoT products.

We ended up deciding to put some trip wires around the room that were connected to WiFi via a Particle board. When it was tripped it sent an event to Keen with a unique id for the laser that was tripped.

We got some hardware to attach to our particle. It included this laser, with this mount, and this photoresistor.

Here was the code we wrote to get the laser working with Particle:

int laser = 0;
unsigned int lastPublish = 0;
bool lastState = false;

void setup() {
    pinMode(A0, INPUT_PULLDOWN);
    pinMode(D7, OUTPUT);

void loop() {
    int val = analogRead(A0);
    unsigned int now = millis();
    unsigned int elapsed = now - lastPublish;

    bool broken = val = 1000) {
        String topic = ((broken) ? "laser/alarm" :  "laser/reset");
        String message = String(val);
        Particle.publish(topic, message);
        lastState = broken;
        lastPublish = millis();

Once we had the laser working we configured a Particle webhook to post to a Keen IO endpoint.

The webhook code looks a little something like this!

   "eventName": "laser",
   "url": "http://api.keen.io/3.0/projects/YOUR_PROJECT_ID/events lasers",
   "requestType": "POST",
   "headers": {
    "Authorization": "YOUR_AUTH_KEY"
    "json": {
      "lasers": {
         "test": "1"

Then events started rolling in!

The next thing we had to do was make some sense out of the data, so we made a real time interactive visualization. We used SVG to make a very rough view of the rooms layout, which happened to just be a rectangle, and then popped two dot’s connected by a line on the page when a new new laser ID showed up in Keen. Once the dots are on the page you can move them around and place them where they physically are in the room.

The last step was to have the line blink to represent the laser getting tripped, in real time. We also added a fun little feature where, if a trip laser is getting a ton of activity, the line gets bigger to represent heavy traffic in that area of the venue.

We used Firebase for persistence, Node + ReactJS for the interface, and Keen IO for the rest. Here’s the app code:

var React = require('react'),
    Keen = require('keen-js');


var config = require('../config');

// Configure Firebase
var firebaseRef = new Firebase(config['firebase']);

// Configure Keen
// https://keen.io/project/KEEN_PROJECT_ID/workbench
var client = new Keen(config['keen']);
var gates = new Keen.Query('count', {
  eventCollection: 'lasers',
  groupBy: 'coreid',
  timeframe: 'this_1_minute'
var totals = new Keen.Query('count', {
  eventCollection: 'lasers',
  groupBy: 'coreid'

var Gate = React.createClass({

  getInitialState: function(){
    var rando = Math.round(Math.random()*300) + 50;
    return {
      a: {
        active: false,
        radius: 15,
        x: rando,
        y: rando - 50
      b: {
        active: false,
        radius: 15,
        x: rando,
        y: rando + 50
      stroke: '#808080',
      strokeWidth: 5

  handleMove: function(i, e){
    var state = this.state[i];
    if (!state.active) return;
    state.x = this.props.trace[0];
    state.y = this.props.trace[1];
    firebaseRef.child('/gates/' + this.props.id).update(this.state);
  handleDown: function(i,e){
    var state = this.state[i];
    state.active = true;
    state.radius = 25;
    firebaseRef.child('/gates/' + this.props.id).update(this.state);
  handleUp: function(i,e){
    var state = this.state[i];
    state.active = false;
    state.radius = 15;
    firebaseRef.child('/gates/' + this.props.id).update(this.state);

  tick: function(){
    var self = this;
    var diff = self.props.weight - self.state.weight;
    console.log(diff > 0, self.props.total);
    var interval = setInterval(function(){
      if (diff > 0) {
          weight: self.state.weight ? 0 : self.props.weight,
          total: self.props.total
      else {
        if (!self.state.weight) {
            weight: self.props.weight
    }, 500);

  componentDidMount: function(){
    setInterval(this.tick, 1000);

  render: function(){

      {'ID: ' + this.props.id}
      {'Total: ' + this.state.total}


var Stage = React.createClass({

  getDefaultProps: function(){
    return {
      gates: []

  getInitialState: function() {
    return {
      ix: 100,
      iy: 100,
      height: window.innerHeight,
      width: window.innerWidth,
      position: {
        x: window.innerWidth / 2,
        y: window.innerHeight / 2

  getKeenResults: function(){
    client.run([gates, totals], function(err, res){
      res[0].result.forEach(function(record, i){
        var id = record.coreid;
        if (id) {
          firebaseRef.child('/gates/' + id).update({
            id: id,
            weight: record.result,
            total: res[1].result[i].result

  componentDidMount: function() {
    var self = this;

    setInterval(this.getKeenResults, 1000 * 5);

    firebaseRef.child('/gates').on('child_added', function(data){

    firebaseRef.child('/gates').on('child_changed', function(data){
      self.props.gates.forEach(function(gate, i){
        if (gate.id === data.key()) {
          self.props.gates[i] = data.val();

    firebaseRef.child('/gates').on('child_removed', function(data){
      self.props.gates.forEach(function(gate, i){
        if (gate.id === data.key()) {
          self.props.gates.splice(i, 1);

    window.addEventListener('resize', this.handleResize);
    document.addEventListener('touchmove', this.preventBehavior, false);

  handleResize: function(){
      'height': window.innerHeight,
      'width': window.innerWidth

  preventBehavior: function(e){

  handleMove: function(e){
    var touch = (e.touches) ? e.touches[0] : false;
      ix: touch ? touch.pageX : e.clientX,
      iy: touch ? touch.pageY : e.clientY

  render: function(){
    var gates = this.props.gates.map(function(gate, index){
      // console.log(gate);
    }, this);





React.render( , document.getElementById('stage') );

module.exports = Stage;

The config.json file has the Keen API keys and the address of our Firebase app.

The index file puts our page on the internet and has is a div placeholder with an id of ‘stage’ and all the things are injected:

  <style scoped="scoped">
    body { margin: 0; }
    svg circle { cursor: move; }


The result was a very fun interactive visual that people really seemed to enjoy. + we got to talk about lasers, double win!

Check it out and hookup your next event and/or let us know what you come up with! Big ups to Dustin and Zach for collaborating on this with me. High-Five

Introducing Open Source Data Explorer

We’re extremely excited to announce the new Open Source Data Explorer, a point-and-click query interface to analyze and visualize your event data.

We believe everyone should be able to use data to make decisions. The Data Explorer makes the power and flexibility of our analytics API more accessible. Now that the Explorer is open source, developers can embed it anywhere — making it easier to build analytics tools for your teams or add value for your customers by incorporating white-labeled analytics directly within your product.

What can I do with the Data Explorer?

The Data Explorer interacts directly with event data stored in Keen IO. It’s an extremely simple and intuitive query interface built to explore event data. All of the analysis functions are built in. Even better, your teams and your customers do not need to know complex query language like SQL to run their analysis. Here’s how you might use the open source Data Explorer:

  • Empower your teams — Quickly empower teams with a tool to easily answer their own questions with data
  • Improve your product — If you’re a SaaS company using Keen to power customer-facing dashboards, you can give your customers another tool to explore the data that matters to them.
  • Build something new — Build a completely new analytics product — Want to build an analytics panel just for product managers? Or your own version of Google Analytics? Data Explorer lowers the barrier for you to do so.

Key features

The Explorer has all the functionality of an analysis tool built in and ready to go. Your teams and customers can intuitively build queries, create charts, and extract data within seconds.

Query building

  • Choose your collection — signups, downloads, pageviews — whatever collection of data you need
  • Choose your analysis type — count, count unique, sum, min, max, average, select unique, percentile, median
  • Ask deep questions by running a group by on any property
  • Build a filter for your query, using the event type as a base for your filter — choose from string, number, null, list, Boolean, or date/time
  • Try out the geo-filter, which enables you to to filter events by latitude/longitude
  • Pick a date and time range for your query using our calendar selector

Visualize the results

  • Toggle between different visualizations of your data, choosing from chart types including area, line, table, or pie. You can also view your results in a metric or JSON format.
  • Embed the charts anywhere by viewing the source code and pasting it anywhere
  • Save your favorite queries, so you can come back and access them again and again
  • Extract your events — view the raw data by sending a full extraction to your email

Why now?

We built Keen IO to solve the increasingly difficult challenge of event data collection, storage, and analysis at scale. We aim to make it easy to not only analyze data via API, but also to expose data to your teams and customers who need it.

Our first couple years at Keen, we focused primarily on building the analytics API and backend tools. While that remains our top priority, we now have a team of engineers focused on building out our front-end and visualization offerings, and Explorer is one of our open source product releases. We’re excited about growing this team to better serve your needs.

We’re so grateful for all of the feedback we’ve received from our developer community along the way. If you have any feedback or questions, please send us an email or ping us on Slack!

Ready to explore your own data? Create a free Keen IO account, check out the sample demo or fork the project on Github.

Happy Exploring!

Thanks for Sharing

The latest iteration of Open Source Show & Tell is now officially a rap. Thanks to everyone who came out to show, tell, learn, helicopter high-five (more about that later), and hang out.

We had a great time and learned a bunch from all of our awesome presenters. One of the ways we know we messed up a bit was by signing up too many community presentations, which meant that not everyone who prepared something had an opportunity to present. We’ll make sure not do that next time, but if there are any other suggestions you have to make the event better please don’t hesitate to send them over via a pull request.

If you didn’t get a chance to attend we will be posting videos of the talks shortly (including the helicopter high-five) so stay tuned. In the mean time, if you’re interested in having an Open Source Show & Tell in your city check out this playbook. Were happy to share our experiences, help you get the ball rolling, and make it a reality.

Thank you to our awesome presenters!

To stay up to date on open source projects and events, subscribe to community-code, an open source open source newsletter!


Keen IO is proud to partner with Rainforest QA and Segment to support the open source community by putting together the next SF Open Source Show and Tell. “What is Open Source Show and Tell?” you may ask. Well, I’m glad you did!

TL;DR: Open Source Show and Tell is a series of events for anyone and everyone interested in open source projects. They are inclusive events that are all about sharing, learning, and getting involved in open source projects (“OSS”).

We will be featuring a presentation by Beth from Microsoft about their experiences open sourcing the .NET platform.

Click here to sign up and join us

Want to talk about your project? :D You can submit talks by posting a Github Issue™

In the past we’ve had many indie developers present their own projects. A couple notable ones are:

  • Alan Schreve on ngrok
  • Alex Gaynor on organizing the python community and doing proper code reviews in a distributed collaborative (and hopefully friendly) environment.

We have also had presentations about internal OSS projects from a wide variety of companies including Google, Airbnb, Uber, Rackspace, Plivo, Balanced, Keen IO, Twitter, and others.

Hope to see you at Open Source Show and Tell on April 24th!

PS. If you’re interested in organizing a #OSSAT in your city here’s a playbookfor more information. It’s open source, so pull requests welcome ;)

Introducing: Data Explorer

We’re excited to release Data Explorer, a brand new and improved version of the Keen IO workbench for querying and visualizing your data.

Many of our customers use the workbench to run ad-hoc queries, create quick charts, and extract data. We’ve made that even easier and more enjoyable with the new Explorer.

To check out the new Explorer, go to your project page in Keen IO and then click on the Explorer tab! Let’s walk through building a query, and some of the new things you’ll see.

If you haven’t sent data to Keen yet, and want to play around with Data Explorer, please check out our getting started guide!

First, build your query:

  • View your event collections and schema without leaving the page, using the new preview button that gives you a quick glance at your schema and recent events
  • Easily select the right collection and parameters for your query, using our dropdown menus. Just start typing part of the word you’re looking for and it will autocomplete!
  • Build a filter for your query, using the event type as a base for your filter — choose from string, number, null, list, Boolean, or datetime
  • Try out the new geo-filter, which enables you to to filter events by latitude/longitude
  • Pick a date and time range for your query using our calendar selector

Next, beautifully visualize the results of your query:

  • Toggle between different visualizations of your data, choosing from chart types including area, line, or pie. You can also view your results in a metric or JSON format.
  • Embed charts anywhere by viewing the source code and pasting it anywhere
  • Save your favorite queries, so you can come back and access them again and again
  • Select the table output to view your data as a simple table

Alternatively, extract your data by email or preview an extraction in the browser:

  • View up to 100 events as a preview table in the browser
  • Send a full extraction to your email, with an optional limit on number of events to extract

Our first couple years at Keen, we focused primarily on building the API and backend tools. While that remains our top priority, we now have a team of engineers focused on building out our front-end and visualization offerings, and Explorer is our first product release. We’re excited about growing this team to better serve your needs.

We’ve also worked closely with a set of customers to test out the Explorer in beta, and we’d love to give a shout-out to them here for their patient feedback and suggestions. We would also like to get your feedback on how you like the new functionality. Email explorer@keen.io with any comments, feedback, or suggestions!

Update: The Data Explorer is now Open Source! You can check it out here.

You can create a free Keen IO account to start exploring your own data. Happy exploring!

Why'd we decide to throw our own conference, anyway?

By now, you’ve (hopefully) heard about KeenCon, Keen IO’s first-ever conference, this September in SF. It’s going to be pretty great, with amazing talks and an adorable outer space theme and a room full of brilliant lunatics, and we really, really hope you can come be one of them.

But, we thought some people might be wondering, “Why are you doing all this, anyway? Keen is pretty great and all, but it’s not comics or Harry Potteror toilets — why do you need your own conference?”

The answer? Arrogance. Blind, burning arrogance.

OK, not really. The real answer is, KeenCon isn’t actually about us. It’s about you — and the power of platforms.

See, at Keen, we’re all about platforms — so much so that it’s kind of the entire point of us. We work really hard to put together some amazing analytics building blocks, but if that was it, we’d pretty much crash and burn. We need you to take the platform we’ve built and run with it — ask questions, build things, play around, get answers, etc.

You do things with Keen we would have never thought of on our own — and the more you do, the better we get: New features, new use cases, even new ways of talking about ourselves — they all come from you building off of our platform.

So, when we started thinking about putting on a conference, we didn’t really want it to be about us (except the name — the “King Kong” pun was too weird to pass up).

We wanted KeenCon to be a platform for platforms, where we could wax poetic on why we like them so much, and hopefully create a jumping-off point for even bigger things.

We wanted KeenCon to show off our customers, show what’s possible, and show what’s coming up next.

We wanted KeenCon to do more than just have people sit and listen to a bunch of talks.

We wanted, basically, to gather a room full of genius superheroes together so they could bounce ideas off each other and walk out inspired and psyched about the next thing they’re gonna build or the next question they’re gonna answer or the next universe they’re gonna explore.

If you check out the KeenCon site (and you should — it’s way cute), you’ll notice that we mention 3 concepts that are pretty important to us: Information, Intuition, and Invention. We didn’t always put a name to those ideas, but they’ve been a driving force behind Keen IO since pretty much our inception, and we believe they’re at the heart of every discovery.

Whether you’re exploring the cosmos, setting out to travel to parts unknown, or digging through data for answers, exploration is all about gathering and mining the raw Information for insight, following your Intuition (sometimes in the face of that data) to see where it leads, and having the Invention to make your own way (figuratively or literally) when you need to. Real discovery happens when these 3 things work together — the data gives you a guide, but you need to trust your gut and make your own way, too.

These are the stories we want to share at KeenCon — not just about Keen, and not even just about tech — but stories about that balance between data and ingenuity and going with your guts. And, honestly, we’ve got some great people to tell them: A famed mathematician, the original architect of the iPhone, a freaking rocket scientist, some awesome founders and developers, and hopefully (hopefully!) you, too. We really hope you can make it!

Tickets are still available for KeenCon — including a limited number of discounted scholarship tickets. For more information about KeenCon, shoot us an email at keencon@keen.io.

(A thousand apologies to the folks at Adobe, for giving us the ability to Photoshop these terrible images.)

Brands are like wine - I consume them both irresponsibly

Wine is one of those things that’s easy to pick up, but takes a lifetime to become an expert in. Sure, some people might say, “But anyone can drink wine! A baby can drink wine.” OK, a.) DO NOT GIVE WINE TO A BABY and b.) very few babies could tell you the varietal, year, and the hill in the Rhone valley where the grapes in that wine came from, simply based on a tasting. (And even if they could, STILL DO NOT GIVE THAT BABY ANY OF YOUR WINE.)

A long-time wine nut, I spent years working as a server and a bartender, discussing wine with sommeliers and customers alike, absorbing all the knowledge I could, and most of all, just tasting tasting tasting as much as humanly possible. Along the way, I started to gain not just greater knowledgeof wine, but also a greater appreciation of it as well.

Something I was thinking about recently, though, is that there is actually a lot of overlap between the experience of a great wine and the experience of a great brand.

(Yes, I had been drinking wine when I thought of this idea, but stay with me here.)

The way I approach wine-tasting is pretty methodical, almost scientific, in its three steps: Look, Smell, and Taste. But, the way I experience that wine is based on way, way more than that — years of experience and intuition and training and discussion. For each of those three areas — Look, Smell, Taste — I have slowly formed different sets of criteria: attributes I look for and enjoy (or do not enjoy), little benchmarks a wine has to clear for me to consider it a success.

Similarly, a great brand is never about just a logo or just messaging or just customer experience; these are only a few of many, many important areas that we, as customers, eventually piece together to create an overall impression of a brand. We can take, for instance, the Nike swoosh and “JUST DO IT” and the design of their products and the tone of their ads and like 8,000 things, and we can mash them all together, and eventually, we start to have ideas about what Nike means. But if you hadn’t been given all that information, and you hadn’t been slowly trained how to think about what all of it represents — if someone just gave you the Nike swoosh, for instance, all by itself, without any of that other stuff — you would think that they were an insane person.

So, when considering a brand, just as when considering a wine, we want to break it down into its component pieces — here, Look, Smell, and Taste.

First, we Look.

When I open a bottle of wine, I immediately take a peek to see what it looks like in my glass. Specifically, I’m looking for color, clarity, and meniscus color. Color gives me some idea of the types of grapes I’m about to have, clarity and the meniscus (the small, clear ring around the edge of the glasses) lets me know if the wine has turned.

Meanwhile, when I’m evaluating the look of a brand, I check out its various assets, copy, and design elements. For Keen IO, these sort of things include our logo, website, social presence, blog, stickers, t-shirts, events, etc. This is our first impression of the brand — everything we tend to notice at first blush, right on the surface. And, just like the meniscus, If any of them seem strange or bad or off-color, well, we probably won’t be giving them much of a taste.

Next, we Smell.

Smell is an incredibly important part of wine-tasting (which is why you so often see people taking those big, crazy whiffs of it), because smell and taste are directly related. When you take in the scent of a glass of wine, it actually primes your taste buds for what they’re about to experience, Is there an oakiness here? What fruit notes can I expect? Basically: What am I getting into here?

In terms of brands, the smell step is that first real interaction we have with the brand. And that could be anything — unboxing a product, having your first meeting with a client, taking your first steps into a shop, whatever gives you a whiff of what it might be like to really work with them. For most of our customers, this would probably include our signup process and welcome emails. These elements are the gateway into the brand, so they should be a welcoming mix of the familiar and the surprising, the comfortable and the delightful.

Finally, we Taste.

Look and smell create an expectation, but taste is the full experience. And the more you taste, the more clear the subtleties of the wine become. In my favorite wines, I get a very clear picture of things like the oak and the terroir (earth notes) in the first sip. Then, as I continue to experience the wine, the fruits and other flavors start to come out: Cocoa, bing cherry, tobacco, leather, etc. But, if you sit down with a glass for a while, it starts to change — the more pronounced flavors step aside to reveal more subtle aspects: A little plum, a hint of moss, grass, stone fruits, fennel, rose. So it’s important to keep coming back over time.

In brands, taste comes down to the long-term experience and value you offer to customers. If your technology is solid and helps solve a problem, people are going to remember it. A positive interaction with the support team reveals something new about the company, and creates a little window into your culture. And, just like wine, brands evolve over time, and start showing new subtleties. But, as long as you maintain some of your core flavor, people will continue to understand and even appreciate these changes.

Of course, there is one last element of the wine-tasting process that I love: Sharing it! If I experience a wine that I love — a wine that fires on all cylinders; look, smell, and taste — I tell everyone I know about it. I open up my Delectable app to put my tasting notes down and see what others have been saying. The same goes for brands; you do a great job, and people will start advocating for you.

At this point, I’m hoping I’ve whet your appetite — both for tasting great wine and for building the sort of brands that people love. If you ever want to chat about your brand, I’m more than happy to help — just buy me a glass of wine to discuss it over. ;)

Announcing Keen-SDK-NET

The Keen IO SDK for .NET is now live! Now .NET developers can track user engagements, errors, server interactions or any custom event type.

We are very happy to have an official SDK to support the Microsoft community of developers. It works for mobile and server side applications and supports the full functionality of the Keen IO data collection API.

I hope you’ll take advantage of this SDK, install it from NuGet, try it in your code and maybe even join us on Github with questions, suggestions or improvements!