Building BrooklynJS

BrooklynJS is a monthly JavaScript event that takes place in Brooklyn, New York. From its start in November 2013 until this was written in December 2015, BrooklynJS had showcased 102 speakers and 15 musical guests for thousands of attendees, who along with 45 sponsors helped raise over $36,000. It grew alongside a new community of JavaScripters that has become one of the most vibrant in the world.

This is my story of how BrooklynJS came to be.

Prologue

My BrooklynJS story begins in 10 timezones away in Tokyo, where I was living in 2013. My girlfriend's startup had decided to move their product team to New York City, so we packed up our stuff and moved to Brooklyn.

Though I was a bit sad to leave one of my favorite cities in the world, I was also excited to live in a city where I could hobnob with JavaScript heroes; John Resig in Park Slope, Jeremy Ashkenas in Brooklyn Heights, and Ryan Dahl in Williamsburg.

But by the time I arrived, Brooklyn's JavaScript meetup had come to an end after its organizer left the borough (or maybe because they couldn't top a Brian Leroux drinkup?), and the Manhattan equivalent, which I had once attended and enjoyed three years prior, had been taken over by a Sencha Touch meetup complete with the ultimate in event code smells, "webinars".

So aside from a handful of small company-specific events, there wasn't much of a local JavaScript scene in New York. But I knew there was elsewhere; shortly after landing in New York, I started a conference crawl that took me to some amazing events over the summer of 2013:

TXJS, my favorite regional JavaScript conference, run by noted identity thief Alex Sexton,
JSConf, the conference that kicked off the modern JavaScript community as we know it, run by Chris Williams,
JSConf EU, JSConf's European cousin, then run by Malte Ubl, Holger Blank, Jan Lehnardt, and Tiffany Conroy,
RejectJS, JSConf EU's first-born son, run by Robin Mehner, and
CSSConf EU, JSConf EU's little sister, run by Kristina Schneider and Michael Pfeiffer.

Each one felt a little like two months of summer camp compressed into a weekend, a bunch of edutaining activities interspersed with jokes and singing. And when they would end, I'd feel a little sad to return home and leave those distant micro-communities behind. So I decided to find a way to bring the fun back to New York City.

Origin

Along my conference travels over the summer, I kept bumping into Brian J Brennan, one of Brooklyn's finest humans, who also wanted to bring the feels of a JSConf-type event back home. By 2013, Brian and I had been to a lot of tech events, but only to attend or speak, and not to organize. Since organizing a big conference with the production value of those in the JSConf family seemed like more work than we wanted to take on, we hatched a plan to take the fun of a JSConf event, shrink it down to 8.33333-ish percent of its original size, and spread it across every month of the year. And since Brian and I lived a short walk away from each other, we decided to give our event a local feel and call it BrooklynJS. In November of 2013, Brian registered the domain, and I created our riff on Chris William's JS logo and set up a website in the flavor of an MTA schedule.

Venue

We looked at a few prospective venues, including a bootcamp code school and some startup offices, but settled on the upstairs room at 61 Local, a pub in Cobble Hill down the street from my apartment. Though we didn't really know it at the time, choosing 61 Local was one of the best decisions we made. Not only did it help set us apart from the usual tech meetup ambiance of pizza and Coors under fluorescent lights, but it also freed us of the awkwardness of holding an event in a office of a tech company. Companies that host meetups see their role as somewhere between charity, in which venue availability can disappear at the first sign of a hiring freeze or more important event, and opportunism, in which recruiters use their captive audience to foist awkward pitches and boring in-house tech talks.

Having our event in a space unencumbered by the agenda of our host meant that we had more freedom to control the tone and personality of our event, to make it more engaging such as by adding music and comedy. But perhaps more importantly, it also presented a symbiotic relationship in which we bring a diverse crowd of a hundred thirsty developers (as in software, not as in real estate, an important distinction in New York City) in exchange for a creative space that we can call our own once a month.

Having a win-win relationship like this was one of the biggest factors in the success of the event. Because our interests were mutually aligned, 61 Local was happy to set aside the space on the same day every month, and would schedule and invoice us accordingly, reducing the busywork of running a meetup in a potentially ephemeral venue. And keeping the event timing predictable in both time (third Thursday of the month) and space (61 Bergen Street) also made it easier for other related events to slot in around us without conflict, and for us to dependably book out-of-town speakers in advance.

More specifically to our setup, 61 Local has been an incredible partner. From the local CSA to their calendar full of interesting events, you can tell they're wired for community. Get there early enough and you can see laptoppers in the morning give way to parents in the afternoon and then professionals in the evening, enjoying their rotating roster of local craft beer, kombucha, and soda.

61 Local's focus on their community has made it easier for us to focus on ours. When their Internet buckled under the load of a hundred nerds, they installed FiOS and a new WiFi endpoint. When their kitchen strained under the load of a hundred mouths, they created a custom branded menu optimized for throughput to keep their kitchen running smoothly. So while we often receive complaints that the venue is too small for the size of the audience we attract, I can't imagine moving; we'd rather see more events than bigger ones.

Talks

The core of a BrooklynJS event consists of five lightning talks of ten minutes each, preceded by an intro in which the emcees give some context for the event.

+-------+ +====+ +====+ +====+ +====+ +====+
| intro | |talk| |talk| |talk| |talk| |talk|
+-------+ +====+ +====+ +====+ +====+ +====+

Talk proposals are entirely open, and take place on GitHub via a pull request, starting the day after the previous month's event. To submit a talk, speakers insert their name and talk title into our website source, and add a description in the body of the pull request. Two weeks before each month's event (and the day before tickets go on sale), we choose five talks from the outstanding pull requests by merging in our choices (and dealing with the inevitable merge conflicts).

Using an open format for talk submissions has worked out well. Having more talks than the average meetup would require more grunt work to curate manually, and we're constantly delighted by the high quality of unexpected proposals from new and returning speakers.

Once in a while we'll exercise a little bit of curation and cajole interesting speakers into submitting, so that the lineup is one we think our attendees will enjoy, but even JavaScript celebrities need to submit a pull request. For first-time speakers uncomfortable with submitting a public pull request, we also offer out-of-band advice and coaching (via Twitter DM, Slack channel, or in-person) before the pull request, so that there's no risk of getting rejected publicly.

Sometimes we'll try to steer people to topics that are likely to be more successful based on our audience. This usually means keeping things from getting too specific, such as talks on tool A (such as testing) for framework B (such as Angular), which would appeal only to a limited section of attendees.

For talks that are not chosen, we give the speaker a code to buy a reserved ticket to the event anyway. This is by far the most reliable way to get often scarce tickets, and is also a cheap and convenient way for us to increase the number of talks from which to choose.

Social

Another one of The Good Parts™ of a JSConf event that we wanted to emulate was the "hallway track", where attendees can interact informally outside of scheduled content. So again we took a cue from Chris Williams, and tacked a beer.js to the end of our event.

+-------+ +----+ +----+ +----+ +----+ +----+ +=========+
| intro | |talk| |talk| |talk| |talk| |talk| | beer.js |
+-------+ +----+ +----+ +----+ +----+ +----+ +=========+

Our choice of venue made this easy, as talks take place upstairs from the bar, far enough to be out of earshot but still in the same building. With the usual conference room meetup format, presentations and conversation can only happen in serial, which is unfortunate when many attendees come for the social.

While we had intended only to give folks an opportunity to mingle after the talks, having a less structured mode of interaction came with other benefits. For example, we were able to avoid the inevitable attendee attrition that takes place at meetups in which attendees post-game at a separate venue. Having a social track also makes it easier for us to accommodate folks that had to stay late at work or couldn't get a ticket but still want to hang out.

We did, however, tweak the "beer.js" brand a little bit to make it our own. Specifically, we took out the "beer". Since the use of alcohol at tech events can be a tricky issue, we wanted to avoid naming our hallway track after it. Also, when it comes to Brooklyn, attendees are just as likely to be avoiding gluten as they are alcohol, and with all the great kombucha and soda the borough offers, we wanted to be more inclusive.

Thankfully, resident pun expert Willman Duffy came up with an amazing JavaScript-specific rebrand: bevera.js. It's so clever; I hope it catches on elsewhere.

+-------+ +----+ +----+ +----+ +----+ +----+ +===========+
| intro | |talk| |talk| |talk| |talk| |talk| | bevera.js |
+-------+ +----+ +----+ +----+ +----+ +----+ +===========+

Music

As any good web developer knows, the best way to keep users engaged is to minimize the time they spend waiting. The same is true of meetups, and critically so for ones with multiple talks straddled by minutes of the awkward dance of getting arbitrary slideshow software on arbitrary laptops to work with the venue's projector setup. In our case, a few minutes of downtime in each of six gaps between blocks could add up around 20 minutes, or two talks worth of time.

To get around this, we tried two technical solutions. The first was to buy a monitor switcher, so that we could plug in two laptops at the same time and switch between them. This didn't work at all due to the cramped space we have for speakers and the latency in having the projector detect each laptop just made things more awkward. The second was to use an Apple TV and have speakers use AirPlay, but this too suffered from poor latency over the network, not to mention requiring Macs to work and allowing only speakers on the device.

So instead of trying to minimize the downtime, we masked it with music. Starting with our second event, each BrooklynJS has featured a musical guest surrounding all five talks with six musical interludes.

       + = = = = = = = = = = = = = = = = = = = +
       |          musical interludes           |
+-------+ +----+ +----+ +----+ +----+ +----+ +-----------+
| intro | |talk| |talk| |talk| |talk| |talk| | bevera.js |
+-------+ +----+ +----+ +----+ +----+ +----+ +-----------+
       |                                       |
       + = = = = = = = = = = = = = = = = = = = +

This worked out well for reasons beyond just mitigating downtime. Musical interludes give the audience a chance to decompress after the mindblow of hearing speakers try to cram half an hour of content into a 10-minute talk, and give us a chance to surface the hidden talents of developers in our community.

Once our first guinea pig musical guest (my barbershop quartet, The Four Fives) survived, we then searched for musical talent within our pool of speaker alumni, where we uncovered Vince Allen's slide guitar, Helen Hou Sandí and her husband Adrián's keyboard and clarinet duo, and Mani Nilchiani's chill acoustic covers. We also cast the net a little wider within the community to find Thorsten Lorenz's jazz guitar, Adam Sontag's Tin Pan Alley keyboard, Pascal Balthrop's eclectic small-town band, and Stephanie Morillo's soulful R&B. And who could forget John K. Paul's stirring rendition of I've Been Workin' on a Rails App.

As our budget grew, we decided to dedicate a small slice of it to also attract other musical acts in the borough. Being in Brooklyn really helped here, as we were able to land some unique acts, including Bathtub Jen and the Henchmen, Bachtopus, Zac Zinger, Jess Ledbetter, and Toot Sweet's Mary Spencer Knapp.

I think adding music to the event was the most effective thing we did to form our own identity. It set the tone of our events apart. BrooklynJS started to feel less like a meetup and more like a variety show.

Coworking

Five months into its existence in March 2014, BrooklynJS had neared its final form, but there was still one more thing to add. Even though we were packing a lively crowd of 100 people into a space designed for 60 all evening, that same space was empty for the rest of the day. So we struck a deal with 61 Local where we got to use the space for the entire day in exchange for them catering our lunch, and Boroughgramming (not to be confused with Brogramming) was born.

                             + - - - - - - - - - - - - - - - - - - - +
                             |          musical interludes           |
+===================+ +-------+ +----+ +----+ +----+ +----+ +----+ +-----------+
|  boroughgramming  | | intro | |talk| |talk| |talk| |talk| |talk| | bevera.js |
+===================+ +-------+ +----+ +----+ +----+ +----+ +----+ +-----------+
                             |                                       |
                             + - - - - - - - - - - - - - - - - - - - +

Boroughgramming is an all-day coworking session that starts at 10am with bottomless Oslo Coffee and a catered lunch, and ends with the main BrooklynJS event. Attendees bring a laptop and something to work on, and we bring WiFi, outlets, chairs, and tables. We take a quick break after lunch to go around the room and talk about what we're working on, and duck out for ice cream at Van Leeuwen in the afternoon. Usually the crowd is split between folks working remotely and folks working on open source or side projects. It's a great place to swap project advice, since there's a good chance that there's a developer there who's deeper into your platform than you are.

For me, Boroughgramming is where the BrooklynJS community really started to gel. Since attendees are equal parts regulars and first-timers, the vibe is familiar without being stale, comfortable without being clubby. As enjoyable as I find the intensity of BrooklynJS, the more casual nature of Boroughgramming makes it a better venue to seek project feedback and get honest opinions on new libraries and frameworks.

Sponsees

Like most community-run meetups, profit is not a goal of BrooklynJS. Since holding on to money we've made from tickets or sponsorships would just complicate my taxes, I want to get it off my books as soon as possible.

We looked at several organizations, but soon found a perfect fit in ScriptEd, a young non-profit here in the city. Their mission is, in their words, to equip "students in under-resourced schools with the fundamental coding skills and professional experiences that together create access to careers in technology". Since developer scarcity is one of the primary reasons tech events like BrooklynJS can attract sponsorship dollars in the first place, it seems right to channel those dollars back to not just creating more developers, but helping broaden the pool of potential developers.

Within two months, ScriptEd became our exclusive sponsee, and two years later, we'd raised more than $30k to help their efforts. While this is decent for a community effort, it's probably not much when compared to donations from deeper-pocketed corporate sponsors. But one way that organizations like ours can contribute more meaningfully is by introducing enthusiastic, like-minded developers within our community to volunteer as teachers in nearby schools.

The ability to build a modestly reliable stream of contributions has also allowed us to give in ways that reinforce our values as a community. For example, BrooklynJS was a top contributor to the The Meyer Family's Fundraiser in honor of the daughter of longtime web contributor Eric Meyer. More recently and close to home, after JSConf announced it was ending due to health issues, BrooklynJS donated a park bench to the Town of Herndon on behalf of the JS community in honor the contribution of its organizers, the Williams family.

Pricing

Since BrooklynJS started, how to distribute tickets has been a significant source of stress.

For our first event, we initially gave away tickets for free, capping attendance at double the recommended room capacity of 60 seats and relying on attrition to make the math work. This turned out to be a terrible idea; our inaugural event sold out in less than two hours, before many of our friends could sign up. So we sheepishly sent out an email to ticketholders that night, letting them know the ticket price would be upped to $5 the next morning, but giving them first dibs on the new tickets. Since these tickets included a free beverage, the end cost to an attendee actually less than zero, but the friction of requiring a credit card was enough to increase availability by decelerating ticket sales (until the event sold out later that day).

For our second event, we doubled the ticket price to $10, but still sold out in under an hour. We raised prices to $15 for our third event, but sold out even faster. At this point, a logical capitalist would have raised ticket prices to clear the market, but since we were aiming for an inclusive community event, we didn't want to limit attendance to those who could afford a more expensive ticket.

We reached out to the community for advice on the best way to distribute tickets, such as giving preferential access to new attendees or holding a lottery, but never really found a solution that didn't create more problems. So in the end, we decided that instead of managing demand, such as by finding a bigger venue and watering down the event to sell more tickets, our efforts were better spent creating more supply by encouraging more meetups like BrooklynJS around the city.

So we left tickets at the current price of $15. They usually sell out within minutes, or seconds in the case of a high-demand event, but such is the unfortunate reality of a popular event.

One clever hack we used to ensure that attendees understood the value behind their ticket was to put our entire budget in a single JavaScript expression. This way, we could turn widely used open source tools like GitHub and Travis into a fun talking point to convey the rigor of our accounting.

Tickets

A $15 ticket to BrooklynJS pretty much covers the cost of attendance. Since the very first BrooklynJS, attendees have had a choice: they can either redeem their ticket for a craft beer or other beverage at the bar, or keep it to pass that money on to ScriptEd.

At first we used a standard roll of tickets, giving one to each attendee when they checked in at the door. This worked well enough for the first two months, but we decided to try something new: instead of using a cheap paper ticket, we would make a custom commemorative token that attendees would be more likely to keep. Both Brian and I had wanted to learn more about 3D printing for a while, so we asked CUBO, a boutique printing shop in the East Village, to make us 100 custom-printed tokens based on the old MTA tokens for our next event. Even though they cost almost $2 more than a paper ticket, if we could get 25 more attendees to hold to their tickets instead of redeeming them for a beer, the tokens would pay for themselves.

The tokens were a total win-win. Since far fewer were redeemed, we sent more money to ScriptEd, while creating a cute keepsake for our attendees. As CUBO's infrastructure improved, we tried higher resolution tokens, glow-in-the-dark tokens, and multi-color tokens. After a year had passed, we took all the redeemed tokens that were just taking up space in my apartment and upcycled them into a commemorative wooden plaque, which we then sold back to attendees to raise even more funds.

Following the MTA's history, we decided next to up the Brooklyn aesthetic and move to wooden Metrocards as our commemorative tickets. After taking a laser cutting class at nearby NYC Resistor with Brian to learn how to cut our wooden plaques, I camped out at their laser cutter for a few hours a month to make Metrocards out of pine, cedar, walnut, and other hardwoods from Ocooch. Once that got to be a bit of a pain we started outsourcing production to Make Mode in Williamsburg.

For our second birthday, we also surprised ticketholders with free BrooklynJS socks made by Sock Club, offsetting the cost by adding an additional sponsor, and selling a third of the batch as higher cost tickets for the next event.

Speakers

One of the things I like about JavaScript is that it's a bigger tent than most languages, used by developers in fields from design to databases to robotics. And the community is pretty fluid; for every developer moving out for the predictability of Go that doesn't come easy in JavaScript, there's a new developer moving in for the power of JavaScript that doesn't come easy in CSS.

While this dynamic may make it harder to stay current in JavaScript compared to other languages, it also results in more diverse and interesting JavaScript meetups, which is reflected in the speakers of events like BrooklynJS, of which there were 102 by the end of 2015.

Perhaps the most satisfying things about organizing BrooklynJS was to see speakers share their first tech talk with us and then go on to the big leagues, getting flown around the world to speak at major conferences. In this sense, BrooklynJS has become a farm team for larger conferences; roughly half of the Track A speakers at JSConf Last Call spoke at BrooklynJS. I didn't really understand it at first, but creating a friendly space in which developers can test out their crazy ideas and find their voice within the larger community is probably one of the most important roles a local tech meetup can fill. Giving good people a platform and watching them meet friends and find work has been incredible to watch.

Siblings

Though BrooklynJS helped reboot New York City's JavaScript community, it wasn't until its siblings arrived that things really started to get fun, as BrooklynJS regulars started to bring their own flavor to sibling events in their corners of the city:

ManhattanJS, by Zahra, Brenda, and Rushaine, on the 2nd Wednesday of the month. They opt for three longer-format talks of 20 minutes, the last of which is a passion presentation where JavaScripters talk about their non-code hobbies, from improvisational dance to making hot sauce. The event is currently hosted by Digital Ocean in Tribeca, with a post-game at Toad Hall.
JerseyScript, by Jenn, on the 4th Tuesday of the month. Jenn cuts to the chase and focuses on chilling with fellow developers in Jersey City, first among vintage video games at Barcade, and then possibly over karaoke downstairs at Porta.
QueensJS, by Sara and Daniel, on the 1st Wednesday of the month. QueensJS starts with an open buffet (get there early), followed by three 20-minute talks, one of which highlights a first-time speaker or junior developer. The event takes place upstairs at Raven's Head Public House in Astoria, and has its own dedicated bartender.

Once QueensJS arrived, we created a loose umbrella organization called BoroJS, which at the end of 2015 also welcomed Nodebots NYC onboard. Having a community that clusters around multiple smaller events with their own focus and personality makes the New York City JavaScript ecosystem really dynamic, and probably has the added side benefit of making it harder to kill when an organizer burns out or leaves town.

Now that there's a community-run JavaScript event almost every week of any given month, it's much easier for folks in from out of town to drop in, hang out with us, and take some of our enthusiam home with them. Jason Rhodes started charmCityJS in Baltimore after boroughgramming with us, and after coming to our CSSConf crossover event, Visnu Pitiyanuvath started WaffleJS in San Francisco, which in turn inprired Emily Plummer and Max Ogden to kick off a Portland version.

So if you're looking to start an event in your neck of the woods and are looking for some advice, hit us up in our Slack backchannel. A good chunk of the BoroJS community hangs out there, and can probably help you out.

Organizing

From finances and ticketing to logistics and development, Brian and I put a lot of work into growing BrooklynJS, in aggregate likely close to that needed to run a conference. As BrooklynJS approached its first birthday, I was starting to feel a little burnt out, which was probably inevitable. I don't think anyone can create an event worth going to that runs itself on autopilot, and it's really hard being playing the roles of outgoing emcee and detail-oriented organizer at the same time.

Prompted by my community organizing senpai, Gary Chou, I mentioned these feelings at the end of a talk I gave at Orbital, the creative space he runs in the Lower East Side. I never really felt comfortable asking folks to help with the administrivia of running BrooklynJS, since it's the least rewarding part, but it didn't matter, because Willman Duffy and Mariko Kosaka showed up anyway and soon become BrooklynJS's new organizers. They were happy to do the behind the scenes work while Brian and I stayed on as the emcee figureheads, which was a great division of labor and made for a really smooth transition.

Willman and Mariko brought a new energy to the event, putting a renewed focus on speaker and topic diversity, while also flexing their respectively considerable skills in puns and knitting. I felt it was important to stay on for a few months to help with the transition, but probably ended up overstaying my welcome before finally handing my emcee reins over Jenn Schiffer and my organizer reins over to Jasmine Greenaway at the end of 2015.

Reflection

For most of my time as a JavaScript developer, I've been a consumer of community events. But making the switch to a producer wasn't too hard; it's a similar jump from being a web app user to a web app creator, to which I think most JavaScript developers can relate. And like any project, I didn't really understand at the outset how much work it would be.

Watching a community like the one we have in JavaScript in New York City has been my favorite part about moving here. Like many things in the city, I'm not sure how easy it would be to replicate elsewhere, due to the density and diversity unique to New York. So I'm not really confident when it comes to giving advice to folks interested in growing their own local tech communities.

But there is one lesson I've learned from the past two years of helping build a successful community: Mutual wins amplify effort. In other words, building community became much easier wherever we found situations in which all actors had an ongoing incentive to participate. Here are some examples from my experience:

It would have been financially safer to let a tech company host BrooklynJS, but because the venue we chose (61 Local) has a direct financial incentive to accommodate us, they've helped us immeasurably in growing the event.
It would have been less challenging to fill speaker slots with developers that look like me (a straight white dude), but diversity is self-sustaining: the best way to attract a wide variety of speakers and attendees was through the social proof of projecting the variety we sought.
It would have been simpler to use off-the-shelf paper tickets instead of slaving over a laser cutter to prototype wooden Metrocards, but once we outsourced production, we were able to increase net donations by providing a memento that our attendees actually wanted to keep.

So while Brian and I tried our best to create an event worth attending, events are by definition ephemeral. But by seeking mutually positive interactions among attendees, speakers, venues, and the rest of the actors by which events are built, we helped shape a community that will continue to exist long after BrooklynJS is swept up by the garbage collector.

Cheap and reliable Node.js hosting starts at $3/month, and $1/month static HTML hosting

jed / building-brooklynjs