4 Benefits Of Solar LED Lights For Parking Lots


//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js

(adsbygoogle = window.adsbygoogle || []).push({});


The future is solar LED lights. You will see them in the parking lots and other large areas around a city. They are cheap and save a good deal of money on electricity bills. Nowadays, the majority of parking lots feature the conventional lights that get their power from the grid. These products are not efficient and add to the environmental pollution. Let’s take a look at some of the prominent benefits of solar LED lights.

1. Energy Efficiency

Solar LED lights are a bit more expensive than the traditional lights but they offer a lot higher return on investment. According to statistics, they are 500% more efficient and stand the test of time. Since they get their power from the sun, they are a lot more efficient.

If you want to figure out the cost of power consumption, all you need to do is multiply the power of all the units of light with the number of hours the light will operate for. Usually, the cost lies between 10 and 20 dollars for each unit on a monthly basis.

2. Smart Technology

With smart technology, solar operators can configure lighting schedules from a remote area. Moreover, they feature smart gadgets as well. They can serve as powerful anti-theft devices and data collectors for the internet of things or large data banks.

3. Luminosity

Why do we get lights? It’s simple. We need lights for the purpose of luminosity. Although watts is the measure of power something consumes, luminosity measures the brightness of light that a bulb produces.

Traditionally, watts represent the brightness of a source of light. On the other hand, solar LED lights have a different convection. As far as efficiency is concerned, they are 400% more efficient. With the help of smart technology, it’s possible to get a better control over the lighting systems that is installed outdoors.

Apart from this, you can increase or decrease the amount of brightness easily. It’s possible to provide the right amount of light in the right area.

4. Environmental Advantages

There are a lot of environmental advantages of the solar LED lights. As a matter of fact, traditional ones get their power from the grid. In the grid, power is produced through fossil fuels, which emits a good deal of pollution in the air. And we don’t need to explain how pollution can cause a lot of health issues.

Since solar energy is 100% clean with zero side effects, it is the future. Moreover, fossil fuel will become scarcer over the passage of time. Research in the world of solar power may bring the prices down in the future.

The installation process for solar LED lights is quite simple. The cost is lower and efficiency is higher.

So, these are a few main benefits of installing solar LED lights in the parking lots. The cost of energy is rising. To help solve this problem, we should turn to the renewable sources of power and solar power is one of them.

Source

Valet: A Realtime Server for Rapid Prototyping

While developing the Robin platform at One Mighty Roar, we’ve found ourselves pushing realtime data between things like RFID kiosks, Bluetooth devices, PHP servers, and various AngularJS frontends. Along the way, we’ve built a simple but flexible server that uses Socket.io and Node.js to make passing around realtime data as simple as possible.

We’ve come to think of Valet as less of a server and more of a tool – once you’ve set it up once, you can use it for many concurrent projects without any customization. In this post, we’ll go over some of the aspects of Valet and how to use it. There’s more information on the Github repo, including detailed instructions on deploying Valet on various platforms.

Installing Valet

Valet simply accepts data and re-emits it to connected clients. A client could be some Javascript running in the browser, a server, an internet-connected piece of hardware – anything that can handle WebSocket connections.

To install Valet, run:

sudo npm install -g valet

To start your shiny new Valet server on

localhost:9200

*, run:

valet

*Note: all of the examples on this page use the default URL http://localhost:9200. If you deploy Valet on a PaaS like Amazon EC2 or Nodejitsu, you can generally drop the port from the base URL.

Event bubbling with socket namespaces

One of our goals when building Valet was to be able to instantly use it for new projects, without writing or deploying any new server-side code. If a single instance of Valet is going to be passing data between multiple projects, it is necessary to separate the connected clients by project. Socket.io can do this out-of-the-box, and it’s called “namespacing”.

Clients (frontends, devices, or even other servers) determine what namespaces they want to join by connecting to a specific URL. Multiple namespaces can be joined by calling

connect

  multiple times (only one WebSocket connection will actually be used). For example, to join the

/temperature

  and

/humidity

  namespaces, your client would have code that looks something like:

temperature = io.connect('http://localhost:9200/temperature')
humidity = io.connect('http://localhost:9200/humidity')

Valet extends Socket.io’s namespaces in a useful way: if you use more complex namespaces, your events and data will “bubble up”. For example, data you send to a namespace like /buildings/123/rooms/456/temperature will be emitted on the following three namespaces:

/buildings/123/rooms/456/temperature
/buildings/123/temperature
/temperature

This means that you can listen to

/buildings/123/rooms/456/temperature

  to get events from temperature sensors in room 456,

/buildings/123/temperature

  to get events from all of the temperature sensors in building 123, or

/temperature

  to get events from all of the temperature sensors, everywhere.

Sending data to Valet

You can pass data to Valet by either sending a POST request to your Valet server, or by emitting a socket event called “post”. For example, to send data from your terminal using CURL:

curl -X POST -H "Content-Type: application/json" -d '{"event":"reading","data":{"temp":83.3826}}' http://localhost:9200/buildings/123/rooms/456/temperature

To send the same data using a socket is a two step process – first, you must connect to your Valet server on the root namespace. Then, emit an event called

post

  containing the

event

 ,

namespace

 , and

data

  you would like to emit. For example:

temperature = io.connect('http://localhost:9200');
temperature.emit('post',{
    event:"reading",
    namespace:"/buildings/123/rooms/456/temperature",
    data:{temp:83.3826}
});

In either case, an event called

reading

  with data

{temp:83.3826}

  will be emitted on the three namespaces above.

Listening for data from Valet

Anything that can run Socket.io can be a client. Simply require Socket.io on your client, connect on whatever namespaces you like, and listen for events.

Here is an example client that listens for temperature readings. To demonstrate the namespace “event bubbling” behavior described above, this example listens for events on the

/buildings/123/temperature

  namespace, even though they will be sent to the server on the

/buildings/123/rooms/456/temperature

  namespace.


    
    http://localhost:9200/socket.io/socket.io.js

    

        // Connect on the "buildingTemp" namespace
        var buildingTemp = io.connect('/buildings/123/temperature');

        // "Connect" events are fired when the connection happens successfully
        buildingTemp.on('connect',function(){
            console.log('connected to the "buildingTemp" namespace!');
        });

        // Listen for the "reading" event we will be POSTing
        buildingTemp.on('reading',function(data){
            console.log('Got data on the "buildingTemp" namespace!');
            console.log(data);
        });
    

Wrapping up

Right now, we’ve got three AngularJS apps, a PHP backend, and a Raspberry Pi all passing data through a single Valet server running on a (free) micro instance on ec2. Setting up Valet in a new project generally takes < 10 lines of code on the client-side, and no work at all on the server-side.

We wanted an always-on, realtime, easy-to-use realtime server, so we built Valet. Hopefully you’ve gotten a sense for how easy it is to start building things that can communicate in realtime.

Valet is extremely young and will continue to evolve as we find new and interesting applications for it. If you’ve got a feature you would like to see, or you come across a bug, feel free to submit an issue or pull request via Github.

How We Did It: Millions of Daily Pageviews, 60% Less Server Resources

Contributed to by Trevor Suarez.

Two years ago at One Mighty Roar we noticed that a side-project from the early days of the company was gaining large amounts of traffic, despite not being touched in ages. Over the process of a few months, we spent some 20% time, which quickly turned into 120% time, revamping You Rather, redoing the site from the ground up, creating an API, and writing both an iOS and an Android app. As a result, You Rather has done some excellent numbers, gained some community garnishment, and been a great project for the OMR team to boast about. But, as most side-projects are, they fall low on the priority list when other new opportunities come along.

At the end of this summer, it became our goal to give You Rather a breath of new life. The first step was to axe the aged Apache HTTP server in favor of Nginx. We’ve been using Nginx for 99% of our work over the last year and haven’t looked back since. However, most of our Nginx experience has been writing .conf files for new sites and servers, never rewriting old .confs for existing production sites.

In just an afternoon, we moved a site with 400+ active concurrent users doing 1k+ pageviews a second, from Apache to Nginx, without any downtime.

Brushing off the Dust

To give some background, we ♥ AWS. You Rather uses every bit of the AWS stack, from EC2 to EBS to Route 53 to S3. To get a “dev” environment setup for ourselves, we grabbed our current AMI of the You Rather site and spun up a new instance for us to hack on.

A simple

yum install nginx

got us Nginx up and running on our CentOS box in no time. Step one, complete.

To start, we tossed up our generic Nginx conf:

server {
    # Port declaration
    listen   80 default_server;
    listen   443 ssl;

    # Server name and aliases
    server_name  nginx-test.yourather.com;

    # Root directory and default index
    root   /var/www/path/of/yourather/src/;

    # Catch-all
    location / {
        try_files $uri $uri/ /index.php?$args;
    }
    
    # Pass the PHP scripts to the PHP-FPM socket
    location ~ .php$ {
        include        fastcgi_params;

        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;

        # PHP-FPM (unix socket)
        fastcgi_pass   unix:/tmp/php5-fpm.sock;
    }
}

Lo and behold, most things…just worked. Granted, we had done plenty of work getting the AMI setup with with Apache and PHP initially, switching over to Nginx was pretty easy to get started. Step two, complete.

Tweaking for Performance

Nginx has a few obvious benefits over Apache when it comes to the server layer, but Nginx isn’t the sole reason for You Rather’s performance improvement. To see why, let’s clarify what exactly makes the difference here.

Where Nginx really shines is that it doesn’t process “.htaccess” files. While those files make for convenient setups on shared hosting plans or shared machines, traversing the file directory for those files occurs on each request, which gets expensive. Nginx, on the other hand, loads all configs in at launch and that’s it, you’re good to go.

Another place we saw had room for improvement was the interaction between our webserver and PHP. Our current implementation of You Rather used

mod_php

with Apache. Although the initial setup for Apache and

mod_php

was quick and easy, a big disadvantage to this is the way PHP is processed per request. Opting for PHP-FPM in favor of

mod_php

gave us significant performance boosts. Where as

mod_php

was interpreting PHP as a part of the Apache process, quickly soaking up large amounts of CPU and memory, PHP-FPM can be fine tuned to get great performance benefits. Utilizing PHP processes that are gracefully launched and killed, Unix sockets, and granular process management, PHP-FPM helped us tune back our overall resource usage on the box. On top of all of these tweaks, now we can tweak configurations for Nginx without affecting PHP-FPM and vice versa without breaking one or the other.

As one last golden bullet to tweak the performance of PHP, we added an opcode cache. Testing out Zend OPCache and APC, we found that OPCache kicked it out of the park for us, boosting PHP processing time and reducing memory consumption overall.

Step three, complete.

Sieging the Site

One thing we’ve gotten better at as a result of You Rather’s traffic is testing our apps under heavy load. On any given day, we’ve experienced large traffic spikes due to social media, aggregators (see: the Slashdot effect), or App Store features. Two tools we use a lot to test load handling are

siege

, and

ab

. For this setup, we mostly used

siege

.

Once we got Nginx serving our site up just right on our dev instance, it was time to hammer the box to see what it could handle. Using

siege

, we could see what kind of a load a single instance could handle. One great advantage of

siege

is its ability to hit an endpoint with concurrent connections, perfect for simulating a real-world use-case of You Rather. Starting the command:

siege -t 1M -c 20 http://nginx-test.yourather.com/

We simulated 20 concurrent users (

-c 20

) hitting the site on that instance, non-stop for a minute (

-t 1M

).

siege

gives great analysis of the tests both during and afterwards. Things looked great from the get-go. The throughput was much lower than the old Apache AMI, and response times were generally lower. We kept tweaking the

siege

test, varying between 10 to 100 or more concurrent connections (protip: don’t go over 75 connections generally, things will break…), hitting different endpoints, like the user profile page, a specfic question’s page, and even the 404 page.

We compared the results from

siege

’ing the Nginx instance to a version of the current Apache site running on a control instance. In short, the Nginx instance performed 100% more transactions, with 50% less response time per transaction. Better yet, we watched the

top

on the Nginx box while testing this out. It handled it like a boss, barely topping out the CPU while slamming it with connections. Nginx was clearly giving the site the boost it needed.

Going Live

Using all of the glory that is AWS, we already had load balancers set up for the site, as well as auto-scaling groups and rules in place for killing unhealthy instances and spinning new ones up where needed. In our search for keeping the site available as much as possible, spinning up new instances under heavy load can get expensive.

Once we made a new AMI for the new deployment of the site, it was time to tweak the auto-scale group to spin up new instances from the new AMI. Using the AWS CLI, we just set the group to spin new instances up from the new AMI. Next, we set the number of desired instances for the group to a healthy number that we knew wouldn’t crash the site, leaving room for a mix of Apache and Nginx instances to be balanced side-by-side.

as-set-desired-capacity yr-production --desired-capacity 4 --honor-cooldown

From here, we slowly killed off the old Apache instances one by one manually, letting the auto-scale group spin a new Nginx instance up in its place. Meanwhile, watching Google Analytics, we still had thousands of pageviews and API calls happening per second, live to the site, including the new Nginx boxes.

Finally, not a single Apache box was left load balanced, we started scaling back the number of desired instances for the group. From 4… to 3… to 2… We probably could have run it all off one box, but for the sake of our own sanity, 2 sounded right.

A week later, we had a bit of a post-mortem, analyzing the numbers. Guess where the Nginx revamp happened:

Our varying number of instances is more or less static now, and has been for weeks:

We have now been serving millions of pageviews and API calls off of two Nginx instances with 0% downtime for a solid three weeks now. Sorry Apache, there’s no looking back.

The Internet of Conference Tables

At One Mighty Roar, we’ve spent a lot of time thinking about how to tackle physical and digital overlap. After creating a textable office sign, a logical next step was to tackle our conference table. We wanted to bring conference furniture to the next level — and to do that, we were going to need lights, proximity sensors, and a “can do” attitude.

The Goal

To spruce up our meetings we wanted a table that not only was classy but served as a memento for our office. We wanted a table that knows if someone is present, is easily accessible over the web, and can show off its lights and hydraulic lift on command. This table would be one of the first stepping stones towards our hackable office.

The Table

With a surface composed of sweet American walnut and was crafted by our friends at Erik Rueda Design Lab. It’s no surprise that our team was huddled in the conference room for an hour admiring the view (we also suddenly became very strict about our drink coasters rule).

Just like most tables in existence, ours has four legs as support, but these aren’t just any normal table stands. If you take a closer look, we found that our logo actually serves as a great reinforcement for table tops.

On top of all of that, our table also comes equipped with some LED housing that runs through the center and around the bottom of the surface. The lights we chose were Adafruit’s WS2801 LEDs so we could easily slap on an Arduino and start programming away.

Finally, the centerpiece is not just a placeholder for our logo, it serves a much greater purpose:

A hydraulic engine lifts up the piece to expose a collection of outlets and Ethernet jacks for laptops and alike to receive some juice. A small switch at the bottom of the table controls the centerpiece vertically, so hopefully we’ll install some sensors to ensure a power cable (or a hand for that matter) will never get crushed in the process.

The Work

After some brainstorming and coffee-sipping, I found some downtime during the week to hack away at this side project. Since we already had an awesome setup for our sign, I began to adapt and expand this codebase for the conference table.

To get started, I gathered up some supplies:

  • Arduino Uno
  • Arduino Ethernet Shield
  • HCSR04 Ultrasonic Sensor
  • Various wiring and power supplies

For libraries we used:

As a quick proof-of-concept, we had previously implemented a RESTful API for our office’s sign, using Webduino.

Once the “tableduino” API library was banged out, the setup was as simple as attaching the Arduino Ethernet shield and wiring the Ultrasonic sensor to the board. We gave the Arduino some power and an Ethernet hookup then started to fire away some API calls.

Here are some of our requests and results!

POST /m-animate
Red = 255
Blue = 0
Green = 0
action = line-fill

 

POST /m-animate
Red = 255
Blue = 255
Green = 0
action = fade

 

POST /b-animate
Red = 255
Blue = 255
Green = 0
action = detect-mode

Making cURL requests or using Postman to hit these endpoints is nice and all, but co-worker Trevor Suarez also created a web GUI to easily interact with the sign and the table using your phone. In the coming weeks we plan on expanding this app for all of our office devices.

You can grab the code for the table from the GitHub repo here.

The Future

What we have so far is only the beginning of what we want to accomplish with our office devices. Down the road we want our API to control the table’s hydraulic motor, halt the engine if an object is detected before closing, and change LED color as more individuals sit at the table.

These are only a few of the possibilities we could think of for the time being. We’re sure as more people play with our table (and possibly hack themselves) in the next few months, there will be more ideas than we’ll know what to do with.

Recruiting Engineers Who Aren’t Scared to Talk to People

We believe to be a good citizen of the developer and open source community is to hire good engineers for One Mighty Roar. This means engineers that can build utility apps like Lantern, connected device platforms like Robin, and hardware projects like Tableduino.

Rules for hiring

When we started, we made the decision to only hire engineers who were fully capable of interacting well with fellow engineers, but can also confidently talk to clients and present at events. Here’s how we we hire tech people with a personality:

Research before setting up an interview

We look at what you have built, who knows you, how you are to work with, what reputation you have, and if folks think you are curious and engaging. We prefer doing it the hard way – talking to people, expanding out networks, looking for talent where many don’t, and ignoring resumes. There are no shortcuts to recruiting exceptional people.

Interviews are free flowing conversations.

We don’t believe in traditional interviews and industry techniques. We want you to do extensive research on us (including diving deep into our GitHub and Dribbble), play with our apps and sites, look at individual Twitter accounts.

Hire makers

It doesn’t matter whether you’re a junior apprentice or an experienced engineer, even non-technical team members should be able to describe you as a “maker”. It shows in your open-source contributions, blogging, and many examples of applications and/or other things you have built and released.

Hire adults

Being an adult doesn’t have much to do with your age, but rather your attitude toward other people, sense of responsibility, and respect for the company. Also, if you are above pitching in to stock the fridge, cleanup, load the dishwasher, or keeping your work areas in respectable shape, these are warning signs to us.

Add people who can add another point of view

Since we are a product development company, monolithic thinking is simply not compatible with our business model. Caveat: you have to be just as comfortable sharing your insights as diving deep into how other members of the team and our clients think.

Look for people with a personal goal

Look for people who are clear on how they want to grow professionally, and who care deeply about personal “brand”. You’re the one that creates the roadmap. The company is just a tool for your growth.

Hire those who grew up aspiring to be an engineer

As we interview, we try to dig deep into when your passion for the craft started, who were your role models, and who inspires you. Those who became engineers because there is money to be made, are not for us.

Find people who can manage your own time, distractions, and workload

You need to find time to work out, eat a proper meal, and take the time-off. You also don’t require monastic environment, because we are not the kind of place.

Hire for the “after 5 o’clock” personality

We pride ourselves on a professional and respectful work environment where you don’t have to put on “corporate face”. That is an unnecessary overhead for a company comprised of genuinely nice, fun, and respectful people.

Strong team, strong company

We fully understand our methodology is not for everyone, but we strongly believe this is something that is allowing us to scale sustainably while handling a large number of projects. This hiring approach is part of what’s allowed us to remain self-funded four years in. The right team makes a company resilient.

Agencies, Product, and the Business of Building for People

“You have clients? So you’re an agency?”

For the first two years of One Mighty Roar, the question of “What do you call yourself?” came up a lot. Externally, people saw as a company with a growing portfolio of brand clients and a trail of websites and social campaigns behind it. Internally, our team saw a growing stockpile of self-made code and tools which tied those projects together. Whatever OMR was didn’t feel exactly like an agency, but it was close enough. So we relented and embraced the byline of “Digital Agency” for the next two years. It wasn’t a perfect description of what we thought made the company great, but the people who mattered understood the difference and that was good enough for us.

A funny thing happens when people hear you have clients — they categorize. Consultants have clients. Agencies have clients. Product companies have customers. Customers who buy widgets or subscriptions to things — prebuilt stuff.


The “sort of” agency

In the early years, being labeled an agency on the outside wasn’t bad. We got to solve challenges for a constantly evolving group of interesting brands and individuals. The answers tended to be websites and mobile applications, but the freedom to build foundations for others inspired us. Our team approached client projects like a product team would. Instead of building for an expiration date of rotating seasonal campaigns, we focused on making reusable building blocks. Some of those blocks were pieces we would later assemble to be products.

At the time we thought product companies required outside funding to get started, and being self-funded is an opportunity you protect. Unlike many early product companies, our business model did not require hitting user count or investment milestones to succeed. Our “funding” came from the projects we contracted. Building for others was great because we were handed challenges to solve pre-validated by the brands and budgets behind them. It afforded us the opportunity to remain self-funded with access to top brands.


From agency to product thinking

Client services aside, One Mighty Roar has two products with enough traction and revenue to have “made it” as independent business models.

One is You Rather, a giant predictive modeling engine based around the game of “would you rather”. At time of writing, it tracks about ⅓ billion responses and a few million views each day. The second product is Robin, a platform that connects digital and physical things by bringing digital layers into physical environments. Despite being early to the “connected device” and “Internet of things” game, Robin has been fortunate to see use from global brands and has grown to a key initiative that powers much of the work we do.

When we interview for open positions, these are the things we talk about first. Without understanding our toolbox, a candidate won’t understand the problems our team can solve. When prospective clients come to us now, we greet them with thinking that supports the products we’ve made. In many cases, it works better than the mobile application or Facebook campaign they originally wanted.

We don’t view product as a way to escape client work. It’s all the same — our client services help evangelize our products. Our products are designed to make certain problems easy to solve. We love when there is a fit, but it’s not a requirement. We are like a toolbox filled with both general tools and some that are unique to us. Some of our best web and mobile application projects have led to new internal workflow, open source projects, and foundations for future products.


Product is a foundation not a department

The products are a part of our thought process right from the start. This is one of the things that a lot of larger agencies get backwards. Let’s take the recent “labs” trend popping up among large agencies. A 500+ person agency tries to recapture its agility by creating a “labs/innovation” department. On paper, lab initiatives feels like product — smart people in a room tinkering with the latest technology to build things their clients can use. What happens instead (unfortunately) is the lab becomes little more than a media kit checklist item to show they are forward thinkers. A handful of interesting experiences might come out of it every year, but the rest of the company doesn’t benefit from the new process, only the results.

Today’s 500+ person agency doesn’t have the cultural foundation to support a product startup inside of it. Hell, there are fifty person agencies that would have a hard time making the product shift. They scratch itches instead of solve problems and fail the test of “different or better?”. Being scrappy is something you can lose with size, but scrappiness is also the catalyst needed for compelling product direction. Scrappy can’t afford to build things with expiration dates.

Clients can sponsor features

Clients can (and should) have goals that extend beyond a single project launch. When building with a product toolbox mentality clients become sponsors for new features, either directly or indirectly. The client gets what they want for their project and we get a good reason to bump a new, client validated feature to the top of the list.
This isn’t to say that you build generic results. The difference is in approach. Simply asking “How would this be done if it wasn’t just for this use case?” nets a lot of design and development decisions which ultimately make stronger product design.

Good products come from domain expertise

People build solutions to their own problems. If enough other people have the same problem, you have a product. If enough people buy in (and they don’t always), you have a business.

Building to a product rather than a project means something is always left to improve. We believe in constantly iterating towards a goal or at least a larger narrative. Whether the product fails or succeeds, you’ll still have the “why did we make this?” to inform the next steps.

Product people and project people

At One Mighty Roar, we are product people who take on client projects. When we interview people from larger agencies, a common thread for departure is burnout from shelved projects or great work that doesn’t exist anymore. Dan Ariely covers a lot of these points in his talk called “What Makes Us Feel Good About Our Work.”

In project based work, it’s harder to be deeply invested in something the moment an expiration date is established. Product represents something to always come back to. Coupled with the diversity of challenges and the brands agency style work comes with, we find a product company with client services gets the best of both worlds.

The fabled “20% time”

Our friend, Richard Banfield of Fresh Tilled Soil, recently wrote an interesting piece which cautions design companies that try to tackle agency and internal product work. One topic covered is the danger of viewing 20% time as an adequate amount of time to develop a product. This magical time is the first to go in busy situations, which can all but halt product development.

Interpretation has changed over time, but the gist is a company spends the majority of time thinking specifically, and the minority is thinking broadly. Google and 37Signals get a lot of credit for being the pioneers in this regard, but it’s 3M we have to thank for subsidized personal projects at the workplace.

We don’t believe that client work disqualifies a company from doing product if you hire the right people and build for the right companies. Put another way, we spend 80% of our time building out customized iterations of our services, then 20% refining for the big picture.


It’s a business, not a lottery ticket

Products aren’t lottery tickets to aid in the escape from your core business. We’ve come to view products as a broader framework for solving problems by improve the toolbox and workflow we tackle projects with. You can’t force it, but if you’re looking for opportunities they will come up a lot more than if you have project tunnel vision.

Products are often, to quote the famed Bob Ross, “happy accidents”.

Improving the Conversation Between Strategists & Developers

Hey developers and fellow strategists, we need to talk.

I’ve noticed that we think differently about our relationship in the builder community. You get excited over hardware, lines of code and open APIs while I seek to influence consumer behavior with technology. I feel like this divide may push us away.

Let’s fix this.


Helping Developers

I’ve realized my role in the builder community is to be your biggest fan. I may never need to code in my life but understanding you as a coder is one way we will overcome this. Here are my promises to you:

  1. I will minimize as many distractions as possible to keep you focused  This includes screening phone call before they get to you, waiting to ask questions until you have time to actually think about them and keeping those boring project management short.
  2. I will make you (and what you work on) look amazing. Remember all that traveling I did last spring talking with techies about our platform? I may have dropped your name a dozen times when talking about it. They were impressed.
  3. I will promote your passion to the people who can pay for it. Translating the work you have done into jargon non-techies will understand is my job and I love teaching people new things. So if I ask an obvious question about how it works, it so I can better promote it to folks with dollar-bills to spend.

 


Helping Strategists

Here’s what I ask of you:

  1. Bug me when you are working on something that will blow my mind. I love when we can geek over technology but I sometimes get busy with client work. Take the initiative and come by to talk about what you are working on. I assure you, I won’t tell you to go away.
  2. Write the technology and hardware used on a Post-It. I know, I’ve asked you the difference between JavaScript and jQuery a hundred times. Let’s keep our sanity and when we are done talking, write down the technology and hardware used so I can Google it later. This will save us both a lot of time (and headaches).
  3. Champion my ideas to find better outcomes to problems. The best success we have at selling our capabilities is to team up and think. Ignore the desire to say it’s impossible on the first try. Ask me questions, goals, and outcomes I’m looking for that could help solve the problem. Sometime it won’t be the first thing that comes to mind.

 


 

Helping Each Other

Making (and keeping) promises like these will help us work smarter when tackling an obstruction across the path. I’ve seen this happen at One Mighty Roar where you’d have a hard time identifying someone as a developer or a strategist because everyone invests in the people around them, constantly learning.

The opportunity to improve this relationship is there everyday. You’d be surprise how much of an impact it can have.

The Internet of Islands

This morning I found a device that would turn my bed into a giant scale.

It’s a high point for hardware. The rise of crowdfunding and the maker’s movement have helped awesome ideas turn into products you can actually own. We live in the future. Everything is wonderful and nothing is wrong.

Unless you count the islands. Those are a problem.

Gilligan’s IoT

What are islands? Turns out when great hardware launches constantly, the connected device space becomes an overloaded tech flea market. The devices are all valuable on their own, but most suffer from “Now what…?” moments of integration with other things. No two speak the same language, forcing real world application to be based on which parts are easy to stitch together instead of best. Everything is technically connected, but design isolates the useful parts.

Islands are isolated grids of connected devices — silos in an “Intranet of Things”. They come in four types:

Ownership islands

A device connects to a closed grid only. Access is through a proprietary gatekeeper which limits available data and features. Most common for security systems or payment processing devices where the data needs to be accurate.

DIY islands

A device is capable of connecting to anything, but you’ll need to build the bridge first. These devices require technical skills to work with anything outside their product family. Most crowdfunded devices targeting the maker’s culture (i.e. Arduino) launch with “if it has an API, it’ll be fine” DIY mentality. IFTTT has started to attack this particular flavor of device fragmentation with support for smart systems SmartThings and Wemo.

Privacy islands

A device generates sensitive data or runs inside private spaces. If these devices were to connect to a public grid, they’d have to stay anonymous. So far IoT has been a homebody, and privacy islands are most common in home automation device grids.

Niche islands

A device connects to a specialty grid with an intentionally limited user base. This island is most common with today’s enterprise IoT platforms, which miss out in the same way an internet for only business websites would.

Islands are not automatically a bad thing. There are plenty of situations (especially with security and privacy) where intentional islands are the right decision. As the IoT space expands, it’s the unintentional islands and fragmentation we need to look out for.

Connected… to what?

Today’s hardware-first approach for the Internet of Things is like having a room full of smart people that refuse to meet each other. Great on paper, independently impressive, but dead silent from the balcony above. “Build it and they will connect” doesn’t work.

A lot of folks talk about “connected devices” and the “Internet of Things” as statements of connectivity. They aren’t. They are statements of context. A device with a Wi-Fi signal and API isn’t necessarily connected the Internet, it’s just accessible. The important part is not the device, it’s what the device connects to.

I’ll repeat that.

The important part of a connected device is not the device. It’s what the device connects to.

The moment you realize this, IoT’s future is no longer about hardware. Hardware is a constantly revolving door of better stuff that makes last year’s thing obsolete. The Internet of Things is a software problem.

Hardware helps software ask better questions

When you start with hardware, software is what makes your hardware work. A hardware focused approach may create great devices, but most fail the “now what” moment of open-ended integration that comes with connectivity. Offering a RESTful API is only the first step. Some try to sidestep this problem by promoting an open source software initiative, but that’s open-sourcing the wrong piece of the equation and most of the responsibility for teaching.

When you start with software, hardware is what helps your software ask better questions. Questions like “How hot is it in here?”, “Who just walked in?”, and “What’s the quietest conference room available?”. All of these examples are answerable only through a combination of software and hardware. What would you app do if it could ask questions about the real world?

Future proofing the device grid

The Internet of Things is a grid, and we’re all responsible for organizing the things we put on it. What’s important is not just the types of things we attach, but how we teach them to communicate. Today one of the popular answers is Bluetooth LE. Last year it was NFC, but years of barcodes, RFID, and QR also carried the torch to today.

The newest spec will always be around the corner. An ecosystem can’t grow on a foundation that needs to be replaced every two years. What won’t change is the translation. The world needs more people building ecosystems and products that celebrate the latest Kickstarter success story instead of panic attacks about differentiating.

Platforms like IFTTT get this. To them, new stuff is an opportunity to build more great tools. Why wouldn’t they want more players? More importantly, IFTTT doesn’t require a monopoly to be successful. It’s part of the pipeline, and can be responsible for all, pieces, or none of specific interactions. Platforms as tools don’t depend on universal usage — just being the best option more often than not. GitHub isn’t the only source control platform folks use, but it’s damn good at the collaborative bits.

We need more onramps

As people realize the connected space is more than Twitter-enabled toasters, more “things” will join the grid. Awesome. The problem now is a lack of structure waiting for them. Something to bridge the islands. There is no good way for the average person to get involved. When’s the last time you visited a site direct via IP address? The IoT needs its version of browsers.

Developers won’t have any problem, but they aren’t always why we build things are they? The early onramp is paved by the folks that get it, but at a certain point you’re joined by people who don’t know how to code. These are the people delighted to build if only they were offered a “hammer”.

Now where’s the toolbox?

Banner image source.

How to Balance a Startup With Parenthood

One of the common startup myths is that single 20-somethings are the most successful entrepreneurs and that they are the demographic that starts the most companies. Zach and Sam may have started One Mighty Roar before they were even legal to go into a bar, but research from the Kauffman Foundation states that the average founder is actually 40 years old. The same report shows that nearly 70% of entrepreneurs are married and 60% had at least one child. So much for the stereotype.

Tons of startups, from Intel to Starbucks, were all started by parents. I am a dad myself and One Mighty Roar has been growing along with my daughter. Before I became a father, I got to work with a number of folks who taught me some really great lessons about balancing parenthood and a startup, and I still use these lessons to this day.

1. Think of Your Partner As Your Investor

Having a supportive home partner is a must, and you run a chance of a very painful and expensive divorce if you don’t manage the relationship and foster that support. Think of your partner as your investor, because that person has more influence than you think. So before you start a company or pick a team to join, take the time to pitch the venture and convince your most important investor. It is worth getting your partner’s support.

2. Choose Your Startup Team Wisely

The team you work with is like a second family. Pick wisely! There are many reasons I joined the OMR team, but their support of me being a parent from Day One has been nothing but an inspiration. When your team supports your choice to be a parent, it removes a large layer of office politics and acts as a great source of energy. Even your single colleagues may be parents someday. You have to set an example and inspire them not to fear it when their time comes.

3. Communicate Your Schedule and Priorities

Conflict and ambiguity bring an unnecessary level of overhead to work and family relationships. To minimize that overhead, communication and expectations-setting should be at the top of your mind daily. I am a huge fan of “Commanders Intent.” We practice it at One Mighty Roar at every level, from apprentice to founder. You have to let people know what you are going to do and what the final outcome will look like. Communicating possible risks and where you need help will prepare your home and office teams to have your back when needed. In addition to providing context to a lot of your actions, being transparent with what you are doing and how you are going to do it adds a level of personal discipline you need.

4. Focus

If it does not serve your family or business – purge it! Often, the first thing to go are networking events. Those are mostly “drink-ups” that have no real business value, anyway. Second thing to go are meetings with people who are either not helpful to your work or who are “takers.” These are folks who rarely, if ever, reciprocate for the time and connections you give them. Lastly, it is very likely you will be jettisoning a bunch of hobbies and other activities now that you are a parent. If you already have kids, you know that “me time” is like sleep at Navy Seals training – you take when you can get it, since you don’t get to plan for it. For me, sleep has become the most sought after “hobby.” Being a parent and getting to work with my team is extremely fulfilling and honestly I don’t care enough to pick other hobbies back up right now. I know I am not alone thinking that way.

5. Manage Your Energy

Energy management is not just for utilities. Business has strong demands on your mental energy, and your new family can take a physical toll. Pulling all nighters for the sake of work is non-sense. Generally speaking, the work you do when you’re up at 2:00 am isn’t top-quality, and you’re only going to have to redo the work again the following day. So don’t waste your time.

6. Set Boundaries

When people at work and at home know what to expect from you and when, you cut out a massive amount of conflicts. For example, my team knows there are certain days I leave at 5:00 pm to pick up my daughter and am not going to be reachable until she goes to sleep at 8:00 pm. On those days, my wife knows I need to be in extra early to pound out some work. Most weekday evenings I do set aside time to work on finance and legal docs, because I do the best work on those then.

That means that one of the weekend days is exclusively for housework, family fun, and other non-work activities. It also does not relieve me of my share of housework. Those are just couple of examples.

There are many many successful companies being led by parents. Motivation you derive from having to provide for your family, the impending college costs for your kids, that retirement you have to build for yourself, and the drive to make your family proud of you are incredible fuel for building a successful company. Take it one step at the time and you can and will put your family and growing business in equilibrium. It is not only doable, it is also extremely fun and fulfilling.

Why Your Agency Experience is Perfect for Startups

You got hired because you have a passion for brands and were able to talk intelligently to the client about Snapchat. You always thought you’d be doing something that had an impact on consumers. Clearly, writing Facebook posts for a cheese client wasn’t what you had in mind when you envisioned your career at a marketing agency.

So you’ve realized it’s time to do something else. The good news is, your skills are not at all limited to agency life. In fact, they are very applicable to the startup world. As a former agency person, let me explain why your skills can work well and are very needed in startups.

Building the right team is the most important thing in the first few years on a startup’s life. A quality product, happy customers… all of that is a result of getting the right people on the bus. At One Mighty Roar, we invest heavily in the people we bring into the company. Every person who ends up on our website has a backstory and lessons learned from their former work lives.

For me, I came to OMR after suffering nearly four years of agency life without much to feel good about. Now, my work as a strategist gives me more opportunities to impact how people use technology. Specifically, my team is working to help the Internet of Things be easier to use and make connected devices work together. I can see the real world business value on projects like this and this is my motivation to keep pushing the notion of what’s possible.

You might not realize the skills you learned while eating lunch lonely at your desk trying to power through a deck. But the truth is, startups are looking for people just like you. We sometimes just suck at writing job posts that reflect the skills we really need, so you may need to look beyond the bullet points and seek us out.

Here are four skills that I promise will make any startup person smile during the interview:

Attention to Detail – The likelihood of clients reading your meeting notes is about the same as getting your time-sheets done on time. However, this attention to detail can help the team keep track of items that need more attention. Your ability to take notes and follow up will be a surprising change to people who are used to being pulled in different directions all day. They will look to you as a valuable project manager and as the organized person to remind them about that pitch presentation that has been sitting on their to-do list for a month.

Distill Thoughts to Actionable Goals – Inside the war rooms of startups, many ideas are talked about with little or no action on what to do next. People with an agency background have been trained to distill a client’s thoughts into goals for the agency to solve or explore. Think of the startup as your client. By coming up with action items for each talking point, you’ll be the envy of the office happy hour.

Focus the Team on Solving One Problem – Remember that time you shut your creative team in a room until they solved how they were going to make a 30 second spot into a 15 second one? Well, the same skill to keep a team motivated and focused applies in the startup world too. While it’s not on most job descriptions, startups are looking for people that can motivate teams members, be their cheerleader, and keep projects on the right track.

Creative Thinking with a Mind to Build – Does it ever frustrate you that your agency doesn’t really make anything? You don’t make products, you advertise them. Building things is exactly what startups do. But what they need more of are people with a maker’s passion — but creative thinking — to solve the daunting “What’s next?” question that many agency folks can’t seem to master. The skills needed here are simple: You have the ability to think creatively on hard problems. This type of thinking happens all the time at agencies; you just don’t have the right team to actually implement the ideas. This is your chance to finally create things that people will use.

I hope by outlining the skills startups are craving will inspire you to consider switching to startup life. Skill level aside, what I believe to be the best reason to take your agency experience to a startup is the power you have to make change happen. Some agencies pitch “pie in the sky” ideas to clients knowing moving forward won’t actually happen. Startups, on the other hand, foster a culture to take on challenges and take the risk to actually execute ideas and try new things. Change is something startups embrace. Watching the success of a startup from the outside is one thing, but being involved in the experience will impact you the way you wish your agency did. Trust me, I work at a startup.