Benjamin Curtis

Proven: Customer interviews save you time and money

2013-05-01T11:01:00-07:00

I’m on my way home from MicroConf 2013, having learned a lot and having had a lot of fun. This was the third year Rob and Mike have put on the conference, and the third year that it has been an awesome experience. As with the previous years, the speakers and the attendees were bright, informative, friendly, motivated, and motivating. If you run a bootstrapped biz, or are thinking about running one, MicroConf is the place to be to really increase your motivation for and your knowledge about running your business.

As an aside, I’m looking forward to BaconBizConf at the end of this month for the same reasons – I have no doubt it will also be a great place to be for those who are interested in getting better at making money. :)

I could write several blog posts about terrific takeaways from this conference, but in this one I want to focus on the urging (especially by Hiten Shah and Mike Taber) to focus on customer development when starting and growing your business. This topic had a particular impact on me at this time because it’s been on my mind the last few weeks.

A couple of weeks ago I had the privilege of attending the Switch Workshop put on by the Rewired Group and hosted by Jason Fried of 37 Signals. That one-day workshop (which I also highly recommend) was entirely focused on how people make purchasing decisions, and how understanding that process can help you find the right customers and give them the value for which they are searching. Going through that workshop really got me in the mindset of putting myself in my customer’s shoes (and head), and letting that drive the decisions I make about my business. I had been interested in customer development before, but that workshop really sold me on just how effective it is to talk to customers about how and why they’ve made the decisions they have made.

I work with entrepreneurs quite a bit in my consulting business (in fact, I work almost exclusively with people who have an idea and are wondering how they can convert that idea into a business), and all too often I see a lack of diligent customer research cause time and money to be wasted, building a product or service that not enough people really want. That’s the bad news. But the good news is that this particular problem is actually easy to overcome! And, even better, it doesn’t have to take a lot of time or money! And, best of all, it’s even fun! That workshop, and the emphasis that Hiten and Mike placed on really understanding your customer, gave me the the information and motivation I needed to implement a process to solve this problem for my own business and help others who face this very common problem.

The super-simplified, fun-to-follow and obscenely-effective process can be broken down into two steps. First, follow Hiten’s advice, and start with a hypothesis, which I’ll paraphrase a bit:

We believe that (some type of customer / customer segment) has a problem (with something or doing something)

Once you fill in the blanks with a very specific description of what you think your ideal customer is and with a description of what the job they want done is, then you are ready to move on to step number two (and this is where it gets fun): talking to those customers. But here’s the trick: Don’t talk about you! Talk about them! Talk about who they are and what they do (thus making sure they really are your target customer, and/or helping you learn about who your target customer is). Then, talk about what they are doing today to solve the problem that you are thinking of addressing. Ask them how they came to the solution that they are using, or how they confronted the problem on which you are focused. If all goes well, you’ll end up talking very little about the product or service idea in your head, and instead you’ll end up hearing a lot about what they do and how they do it, which will give you such good insights that you’ll find yourself smiling as they are talking.

Of course this process isn’t limited to just new ideas, products, or services. You can use this same process when working on a new feature for your current product, or when trying to find out why what you are currently offering isn’t quite as successful as you’d like it to be.

Now, you might be wondering how I know this process is worthwhile and fun. It’s because I’ve done it myself, of course! :) And I can certainly attest that it works wonders. In fact, I got to practice the process while still at MicroConf, since some of the attendees are ideal customers for my Rails application monitoring service, Honeybadger. There’s a new feature I’ve been thinking about the past few weeks, and I wanted to make sure I was on the right track with it. I had a hypothesis that Rails developers would like a better way to do activity X than the way they are currently doing it. So I found a few Rails developers that I had already been talking to during the conference, and I asked them one question: When do you do activity X and why? From that one simple question, and a short conversation that followed it, I realized that I was indeed on to something with my planned feature. More importantly, what I heard from my customers let me know that my planned approach was actually a bit flawed. And better yet, I realized that the approach that would better solve the problem (as they saw the problem) would actually be easier for me to implement than my initial plan. I was thrilled!

I hope my small and simple experience of doing customer development – and particularly interviewing customers – has helped persuade you to get out there and do it yourself, if you aren’t already doing it.

If you think this sounds interesting, and you’d like some help saving time and money while using this process to help build your product or your next feature, do get in touch. I’ll be happy to answer your questions or provide whatever help I can.

Rails Caching Strategies (a presentation)

2012-12-05T20:55:55-08:00

Tonight I gave a presentation at the Rails Meetup in Seattle on caching strategies with Rails, and I had a great time. I’m convinced Rails developers don’t use caching enough, and we have so many good options for caching in our apps, we really should be avid practitioners of caching. :)

I had a request to put my slides up, so here they are. They are a bit more useful if you have the context of the words I said along with them, but that’s the way these things go, right?

For those of you who were there, I suppose I should apologize for mentioning (so many times) the Airbrake competitor that I recently launched. After the 2nd or so time I mentioned it, it became a bit of a joke to see how many times I could mention it, and I do hope I didn’t annoy you. :)

Looking for Ruby and Rails developers

2012-10-04T09:22:00-07:00

I’m on the hunt for development help, so if you’ve been working with Ruby and/or Rails for a while, and you’re looking for some contract hours to fill, I’d love to hear from you.

A fellow entrepreneur here in Seattle and I both need someone part-time, so between the two of us, we might be able to use all the hours you can spare. We’re both open to intermediate through advanced Ruby/Rails developers, with hourly prices from $60 to $120, with at least 10 to 20 hours available per week. Both of us are looking to work with a developer for an extended period of time, so this could be the beginning of a beautiful friendship. :)

My needs include getting help with RailsKits, and Catch the Best. If you end up helping me with RailsKits, that could lead to additional engagements, as I’m often getting requests from people looking for development help to tweak the Kits to meet their needs.

My entrepreneur friend is looking for help for his bootstrapped startup, which is in the early part of its development cycle. If you are on the more advanced end of the spectrum he’ll be looking to you to help coordinate the efforts of more junior developers, which means you’ll be able to focus on the bits you find interesting. :)

I won’t bore you with a required skills list – if you’ve been developing web apps for at least a year or two, then you’ll be comfortable with (or be able to quickly learn) the whole stack of technologies that we are using.

To get in touch and let us know you’d be interested in us throwing cash at you in exchange for your talents, please submit your info here. Be sure to include a link to your github profile, a brief run-down of your relevant experience, and your desired hourly rate. This is a contract/1099 arrangement.

Missing attr_unsearchable in ransack?

2012-09-20T13:30:00-07:00

If you are upgrading to ransack from meta_search, and you are missing being able to use attr_unsearchable to hide various model methods from search, you can add this to your model instead:

def self.ransackable_attributes(auth_object = nil)
  (column_names - ['company_name']) + _ransackers.keys
end

In this case, company_name will no longer be searchable with the dynamic scopes that ransack creates.

Easy mobile device login for Rails apps

2012-09-10T07:17:00-07:00

I read an article this morning on TechCrunch about an upcoming service that makes it easy for developers to add mobile logins to their web applications, and I thought I’d try something similar for a new project I’m working on.

If you use the Devise gem for managing logins for your Rails app, and you pass the :token_authenticatable to the devise method, then your users can log in with a link that includes an authentication token, bypassing the email/username and password login. With that in place, all you need to do is generate a QR code that encodes a link to your app with this authentication token included. Here’s how you can do that:

Following the instructions of the qr code gem, install the gem by adding gem 'rqrcode' to your Gemfile and running bundle install. Generating the code can be done in a HAML view like so:

- qr = RQRCode::QRCode.new(root_url(Devise.token_authentication_key => current_user.authentication_token), :size => 10, :level => :l)
%table
  - qr.modules.each_index do |x|
    %tr
      - qr.modules.each_index do |y|
        %td{ class: qr.dark?(x,y) ? 'black' : 'white' }/

This assumes that you have devise hooked into your User model, and the currently-logged in user is available to the view via the current_user method. Using the CSS from the rQRCode home page, this will display a QR code that can be scanned on a phone.

This will allow a user to log in to your app (using their laptop), scan the QR code on their phone, and then be logged in on their mobile browser. Easy. :)

Print Progress Bar Background Color in Chrome

2012-09-08T09:04:28-07:00

I’m working on a project today that uses Twitter Bootstrap, displays progress bars, and has a requirement to print those progress bars. Sadly, Chrome doesn’t like to print background colors by default, so printing the progress bars didn’t work so well. Here’s the trick to get it to work: -webkit-print-color-adjust:exact. This instructs Chrome to print the background color.

After that, adding a few more styles (in a print stylesheet) makes for nice-looking progress bars (SCSS):

.progress {
  background-image: none;
  -webkit-print-color-adjust: exact;
  box-shadow: inset 0 0;
  -webkit-box-shadow: inset 0 0;

  .bar {
    background-image: none;
    -webkit-print-color-adjust: exact;
    box-shadow: inset 0 0;
    -webkit-box-shadow: inset 0 0;
  }
}

Googlebot Gotcha

2012-02-28T06:33:00-08:00

Did you build your site thinking that googlebot can’t understand your javascript? I did, and I was a bit surprised when I learned I was wrong…

About a month ago, Starr Horne and I launched a reboot of OfficeSpace.com, which is all about helping people who are looking for office space find it. We’ve had a lot of fun trying out various techniques and technologies, including trying different approaches to analytics.

I was very interested in tracking on-page events, in addition to the usual page views, etc., so of course I implemented events tracking with Google Analytics. I also wanted to track those events internally, so along with the call to GA, I make a post ajax request to a Rails metal controller that logs the events in Redis. For example, when the map view gets loaded, pins get dropped on the map for buildings that have available office space, and a trigger is set on the markers to pop up a dialog with more info about each building. When the click event fires, json is fetched, the dialog is displayed, and a post is sent to the stats collecting controller to track an event for previewing a building. Since the request was a post and was triggered by javascript, I thought that only humans would trigger it. As I watched the logs, though, and saw googlebot posting to the stats tracker with data from the pages it was loading, I realized how wrong I was.

So now I’m a little wiser and a little more rigorous about keeping bots from creating data they shouldn’t be creating. I’m also now more curious about just how much dynamic content googlebot can index. :)

Skipping Asset Compilation with Capistrano

2011-12-13T05:55:56-08:00

Capistrano has a handy task that runs rake assets:precompile for you when you are deploying your Rails 3.1 application. This gives you an easy way to get the performance boosts of having only one css file and one javascript file to load per request. The price you pay for that benefit is the amount of time it takes to run that rake task when you are deploying. There is a way to get the benefit while reducing that cost, though.

Since capistrano creates a symlink for the assets that is moved across deploys, you really don’t need to compile those assets for any deploy where the assets didn’t change. Instead, all you need to do is move the symlink. However, the default capistrano for compiling the assets does compile them every time, regardless of whether any assets were changed in the set of commits that you are deploying. The trick, then, is to check the list of files that were changed in the range of commits that are being deployed, and compile the assets only if assets show up in that list. And here is a code snippet that does exactly that:

It only supports git, as that’s what I use, so if you use git, just drop that snippet into deploy.rb and enjoy quicker deployments.

Deploying New Relic Server Monitoring with Chef

2011-12-08T06:03:11-08:00

This morning I deployed New Relic’s new Server Monitoring feature for the first time (I’ve used Scout previously). It’s cool to see your server vitals right next to all your app vitals, and their interface looks attractive, to boot.

Since I deploy everything with Chef, I threw together a quick Chef recipe to automate the installation of New Relic’s server monitoring agent. It has been tested with Ubuntu 10.04 LTS, and you can configure the license key in your Chef JSON config.

You can grab the recipe from my Chef recipe repository at Github.

Improvements to Bundle Watcher

2011-09-17T08:32:05-07:00

I just released an update to Bundle Watcher this morning that may make it a little easier to get your Ruby gem updates tracked. Now you can specify a URL where your Gemfile.lock resides, rather than having to upload a file.

You can also now see a list of bundles that your tracking, once you’ve logged in via Github. This list shows you at a glance which gems have been updated for your bundles.

Faker 1.0 released

2011-09-10T10:43:39-07:00

Earlier this week I released version 1.0 of the Faker gem. It’s been about 4 years since the initial release of the gem, and the API has been fairly stable for the last couple of years, so I figured it was a good time to make the jump to 1.0. :)

This release finishes the conversion to I18n. Just about everything is in the locale files now, including the ability to define custom formats for everything – company names, street addresses, etc. And, with the magic of method_missing, you can add new items to your locale file and have them show up as methods in the Faker classes.

The 1.0 release also settles some long-standing issues people have had with bad interaction between Faker, Rails 2.3, and locales (especially fallbacks). Though I’m not actively seeking to support Rails 2.3, I at least don’t want it to be broken, so this release should cover that. Both Ruby 1.9.2 and 1.8.7 are fully supported.

Finally, I want to send out a big “thank you” to everyone (and there are a lot of them) who contributed code and ideas to this release. I really appreciate the interest shown and the work done by so many people who use and love Faker. According to rubygems.org, it has been installed over 400,000 times — over 1,000 times in the past few days!

Of course, I’m not done yet… next on the feature list is Faker::Image, which will provide an interface to all those cool fake image generator services out there. :)

CentOS 5.5 net install secret

2011-09-09T00:00:00-07:00

Today I needed to spin up a VM with CentOS 5.5. My preferred distro these days is Ubuntu, and I had to learn the CentOS dance to get an unsupported version installed, so it took me a little longer than I would have liked to get it going. Here’s the secret:

When asked for the name and directory of the install image, enter vault.centos.org for the name and 5.5/os/x86_64 for the directory. If that doesn’t work for you, go back a step and disable IPv6. After that, you should be good to go.

BundleWatcher: Watching Your Gems

2011-06-20T05:40:23-07:00

My weekend project this weekend was BundleWatcher, a tool that does just one thing: watches the gems in your Gemfile for updates. Once you upload your Gemfile.lock file, BundleWatcher will keep track of updates to the gems upon which your project depends, and you can use the atom feed for your bundle to know when updates have happened.

I built this to scratch my own itch. While rubygems.org provides a way to subscribe to gem updates and an RSS feed to track those updates, I wanted a way to track updates for each of my projects, project by project. Now instead of just knowing that the inherited_resources gem got updated, I can see which of my projects might need an update because that gem got updated.

BundleWatcher uses the (fantastic) API provided by rubygems.org to keep track of gem updates, so as long as you depend on gems that are listed there, you’ll be good to go.

Chef Tips

2011-05-25T06:20:28-07:00

One of the best things that came out of using EngineYard Cloud was learning about Chef. Chef has changed my world when it comes to managing servers, and I now wouldn’t do any amount of system administration without the kind of automation and scriptability Chef provides. Here are a couple of tips on the reasons for and the benefits of using Chef.

Tip #1: Chef keeps you honest

Yesterday I was reminded just how useful Chef can be when I updated the wordpress layout on a client’s server just by running ./config/chef/runchef.rb from my project folder. Not only did the files I changed get pushed out (as you would expect), but I also saw a note in the output about a config file changing. Curious about the unintended change, I did a diff of the just-updated config file with the backup file created by Chef. The diff reminded me that I had made an emergency manual change on the server that I hadn’t yet added to my Chef config (bad me). Since Chef told me about the change to the file, and gave me the location of the backup it made just before changing the file, it was easy for me to find the differences and add them to my build templates (and commit them to my git repo).

Tip #2: Use Vagrant for Chef recipe development

Recently I started working on a new slice configuration since I need to move slices away from slicehost. Since Linux distributions and software packages are always being updated (like Debian 6 and Passenger 3.0.7), I like to start with my stock set of Chef scripts and update them for those kinds of changes. I’ll start with a clean installation of a Linux distro, and fold in my recipes one by one, making sure each is using the best method of installation and configuration. Vagrant is a great tool for this kind of development for a few reasons:

It’s free: You aren’t spinning up an instance at EC2 or Rackspace Cloud to get a clean starting point.
It’s quick: Again, you aren’t depending on EC2 or RS load times, and bandwidth isn’t a problem.
Local filesystem: If you want to start a Chef template from, say, a package-installed config file like /etc/ssh/sshd_config, all you have to do is cp /etc/ssh/sshd_config /vagrant/cookbooks/ssh/templates/default/sshd_config.erb since Vagrant mounts your current working dir to /vagrant on the virtual machine.

Even if you aren’t managing a farm full of servers, Chef is still fantastic to use. I use chef-solo to manage all the servers for my clients, and it makes it easy to have repeatable, predictable deployments for all of them. If you haven’t used it yet, do grab Vagrant and give it a shot.

Jekyll: Pagination, Archives, and Excerpts

2011-05-23T05:53:48-07:00

I recently converted this blog to jekyll — I figured since I had to move my slicehost slices elsewhere anyway, I might as well ditch wordpress and play with something new. It’s been a bit of adventure getting the site rendered by jekyll to match the URL structure I had in place with wordpress, so I thought I’d share some of the code I found and wrote to make it work.

The first step was pagination. My old page links were in the form of /page/2, rather than page2 like jekyll’s default. This was an easy fix, based on some comments in the Google group. I just copied the pagination.rb from the jekyll gem into my _plugins directory and changed line 32 as follows: newpage.dir = File.join(page.dir, "page#{num_page}") to newpage.dir = File.join(page.dir, "page/#{num_page}")

One thing I didn’t see in many of the blog posts I found about converting from wordpress to jekyll was detailed information on generating archive pages. Those are the pages in the form (for my layout) of /year/month, where you’d see all the posts written in that month. Using the category plugin from Recursive Design as a starting point, I added year and month output, with pagination, with this archive generator plugin. I used a similar block of pagination code (which is just lifted from jekyll’s pagination code) as a modification to Recursive Design’s category plugin to get pagination for my category pages, too.

Finally, I wanted excerpts, or “read more”, like you are seeing in this blog post, and I didn’t find any existing plugins that did it, so I wrote one. My excerpt plugin for jekyll creates an excerpt with the content of the post it finds before the –more– comment tag, if there is one. In my index views, I assign excerpt = true to get _includes/post.html to render the excerpt view rather than the full content. On the full post view, post.html renders the full content, with the –more– comment tag replaced with a #more anchor that can be used as a link target to continue reading where the excerpt left off.

After all that, and after a few other nips and tucks, my new site looks almost exactly like my old site. :)

Pricing Experiment Follow Up

2011-04-30T08:14:00-07:00

Thanks so much to those of you who helped me with my pricing experiment. I feel it was a success, with a lot of great feedback.

Before I launched the survey I had a price in mind, but I wanted to see what the prevailing opinion would be on what the price should be without being influenced by that info. I was pleasantly surprised to find that many of those who responded were willing to pay more than the amount I had in mind, which makes me feel good about the value of the products I offer via Rails Kits.

The OAuth Kit has now been priced and released, but I’ll leave the survey open a little longer to let a few more folks get the coupon. :)

A Pricing Experiment

2011-04-28T16:15:12-07:00

Today I read about determining pricing by surveying your customers, and it just so happens that I have a new product ready for pricing, so I thought I’d try it out.

I am ready to release the OAuth Rails Kit, which gives you a good example of how to integrate Twitter, Facebook, and LinkedIn into your Rails app. If you’re like me, you’ve probably been asked to pull data in from LinkedIn, or push out updates to a user’s Facebook stream. This Kit shows you step by step exactly how to that. The only thing I need now to start selling the Kit is a price. :)

That’s where you come in. After you check out the product page, head over to this one-page, seven-question survey that seeks your input on what I should charge for the OAuth Kit. In exchange for your time, you’ll get a 25%-off coupon code that you can use towards a purchase of the OAuth Kit.

Thanks for your help – I’m looking forward to seeing how this turns out!

Update

The Kit has now been priced and launched. Please see the results of the pricing experiment, or go ahead and buy the Kit to easily integrate Facebook, Twitter, and LinkedIn APIs in your Rails app. :)

Auto-spawning Delayed Job Workers

2011-04-12T11:49:14-07:00

I’ve been interested in simplifying lately…. using Chef (solo) to configure boxes, switching to Postgres from MySQL to get decent text search without having to run sphinx, etc. My goal recently has been to cut down the number of moving parts in my deployments to make my life a little easier. So when a client project required background processing, I re-evaluated my stock approach to see if I could simplify a bit.

I’ve been doing background stuff with Rails for a long time, so I’ve used backgroundrb, backgroundjob, delayed_job, and, most recently, resque. I’ve enjoyed them all. :) This time around, I decided to give delayed_job another go in order to avoid having to add redis to the deployment mix just for background jobs. There won’t be a lot of background jobs in this project, so I don’t need a number of workers (which would be perfect for resque), so delayed_job seemed a good fit to run these jobs.

The problem was that I still needed a daemon running (the worker process) to get jobs to be processed, and I was looking for a way to avoid running (and monitoring) yet another daemon. Enter pedro’s fork of delayed_job, which automagically spins up and spins down a worker for you as jobs get created and the queue gets cleared. Since my partner on this project went with collectiveidea’s fork of delayed job, I decided to combine pedro’s work with collectiveidea’s more recent updates into my own fork of collectiveidea’s 2.0 branch (which is targeted at Rails 2.x).

Using this fork of delayed_job, you don’t need to worry about running a worker process. When a job is created, a check is made to see if a worker is running, and, if not, one is spawned (either as a process via the rush gem if you’re on a standard box/slice, or as a heroku worker via the heroku gem if you’re on heroku). When the job queue gets processed, the worker is stopped if there are no more jobs in the queue. It is so awesome. :)

Since we are deploying this client’s code to both heroku (for staging) and EY cloud (for production), the delayed_job initializer looks like this:

Delayed::Worker.auto_scale = true


  if Rails.env.production?
  Delayed::Worker.auto_scale_manager = ENV['HEROKU_APP'] ? :heroku : :local
else
  Delayed::Worker.auto_scale_manager = :local
end

Auto-scaling delayed_job workers makes everybody happy — long-running tasks go in the background, and you don’t have to add even so much as a chef recipe to your deployment. :)

Quick Tip: Sending Google Chart links via email

2011-02-24T11:00:45-08:00

Recently I had a client who wanted to deliver reports via email that contained a bunch of charts, and we decided on using Google Charts for the chart rendering. I used the googlecharts gem to create the links to Google. I encountered a problem with the charts not showing up in Gmail, even when the exact same code was working when viewing the reports at the site in the browser.

It turns out that the pipe character used to delimit data, options, etc., in Google Charts URLs didn’t play nicely with Gmail. Once they were encoded (converted to %7c), it worked like a champ. So, in my (html) email views, I have this as the src attribute to image tags:


Gchart.line(..., :format => 'url').gsub('|', '%7C')

Problem solved. :)

Faker 0.9.0 released

2010-12-21T22:07:22-08:00

It’s been two-and-a-half years since the last release of the faker gem, so it’s about time for another one. :) For a long time I’ve been kicking around the idea of using the I18n gem to make it easier to support different formats (think zip codes in the US vs. postal codes in the UK) without having to change the method signatures, so I sat down today to give it a whirl. I was pleasantly surprised with how quickly I was able to get it implemented, so kudos to the folks who have done all the hard work of making that gem work as well as it does.

In fact, my love for that gem has grown over the last several months as I’ve used it on a few different projects. I had one client who wanted everything localized in his Rails app, which helped me get familiar with it (and eventually enchanted with it). One thing that I found fun to do (which may indicate I’ve crossed the line into gem abuse) is to store starter data in the locale files. For example, if you wanted to give new users a sample list of groceries when they create an account in your grocery list tracker app, you could do something like this:

Then you can create a list of groceries in the user’s native tongue.

So check out the latest faker, and find crazy stuff like that and more! :)