Dev Blog

Go at Paperless Post

Next month, a group of people from the Paperless Dev team (including myself, @aq) will be attending GothamGo in NYC. I’m very excited to meet other gophers and get to talk shop. In thinking about attending I realized that though we’ve been running a large scale Go application in production for over a year, we’ve been relatively quiet about our work.

How I got Go’ing

It’s been over three years since Blake Mizerany started talking my ear off about Go. Blake is one of the people that I tend to listen closely to when talking about programming, so when he told me I needed to spend some time learning Go, I started looking for an opportunity to dabble. I immediately liked its simplicity, the robustness of its standard library, and its speed. It took me a while, however, to find the real gateway project that would take me over the initial hump.

A lot of my work at PP over the past 5 years has revolved around our rendering and image pipeline. When we deliver cards to users they come as rendered images of the creative designs they’ve customized in our design tool. The rendering, processing, and storage of these images is by far the most intensive part of our infrastructure and always one the parts that needs the most upkeep and rethinking as we grow. For a very long time we were able to rely on shared storage (NFS) and ImageMagick to do the storage and processing of these images (KISS), but that started to show some big faults under pressure. An idea started to come together when looking at the problem and playing with Go. What if we could process these images in memory, and then store them somewhere distributed - that would probably be a lot faster and more reliable than reading and writing them to NFS, right? That’s when I discovered the magic of cgo.

cgo and magick

cgo is not one of the most often talked about or touted features of Go, but as someone who’s tried to and failed at working with Ruby’s C-ext support, cgo really seemed like some alien gift from the future. Even though Go’s standard library was great, the number of packages to solve common problems was small (especially 2 years ago - this has changed). With cgo, however, any problem that’s been solved in C is easily ported to Go. In fact, because of how easy, fast, and no-effort the compilation and deployment of Go wrappers around C are, it makes you want to wrap everything. So I started diving through the C source to ImageMagick (specifically MagickCore) to try to wrap our common use cases in simple Go methods. This became magick. It took some work in the background, but I proved part of my idea - that you could work on these images in memory (with a simple API) and it would be (much) faster than our current methods.

From there, it took a little while to convince the team to start work on the bigger idea: using magick to build an image storage and manipulation service in Go. Myself and my former colleague @mrb worked on the project, which we call Agency, on and off for 6 months before we took it across the finish line in October of last year. Since rolling it out Agency has stored and processed over 85 million images, and does so using about 1/4 of the resources of our previous pipeline. I’m happy to say it’s up there with one of the the most stable and predictable parts of our infrastructure.

This year I’ve worked a bunch on refactoring and improving Agency as its usage has grown. We’ve extracted some more pieces of it in an attempt to make the pattern of simple TCP request/response services grow within our team and infrastructure. This project (we call it tcpez) is forming the foundation of another new project that we’re working on currently that should vastly improve our rendering pipeline. We’re busy testing it, but we’re planning on open sourcing tcpez in the very near future.

Why Go

After 3 years of dabbling and one year where its been my primary focus, I’ve come to love working with Go. It has a simplicity that allows for a really quick route from idea to implementation. It has some rough edges for sure (type inference, error handling), but hitting them is pretty rare if you program “within the lines”. As a programming environment, it’s unbelievably good: great tools (testing, pprof), fast and no brain complication, and great standard library. And with every other language that I’ve taken on very seriously, I enjoy programming with it. Go is not meant for solving every problem, but the problems it solves (concurrent networked services) it solves really well.

A very large number of people have recently been speaking Go’s praises and have been switching to it. I’ll never do that, because I am 100% programming environment promiscuous. While working in Go for the past year, I’ve also written a large amount of code in a large number of languages and environments (Ruby, JavaScript, C, Scheme, Lisp, Chef, Docker, etc). At one point, I proudly called myself a Rubyist, but I’ve since seen the error of my ways. Aligning yourself with a single environment and community is dangerous, because as a programmer your primary job is to learn and get better at your craft. And the craft of programming is infinitely larger than any single language can provide. I truly believe the same with regards to infrastructure and our programming stack. No one environment is ever going to do a good job fitting into every nook of your application. Strive to look for good solutions instead of just good tools. I can say from experience that there are some great ways to make different language environments and applications speak to each other (See: protobufs).

At Paperless Post, we’re investing in Go as we think it hits a sweet spot for key parts of our application. We still use and love Ruby, too. If you’re interested in working on either of these kind of problems come find and talk to us at GothamGo in NYC or a couple days later at RubyConf in San Diego.

Welcome Tatum Lade as the CTO of Paperless Post

I’m very excited to announce that this week Tatum Lade has joined Paperless Post as our new Chief Technology Officer. Tatum is coming from a tenure at Boxee and Samsung, where he helped grow the product and the team while also leading R&D. We’re looking forward to having him bring his tech and management expertise to the CTO role and empower us to continue to expand our product and development team.

I (Aaron Quint) am staying full time at Paperless as Chief Scientist, a new role that will be focused on solving our team’s biggest technical challenges.

When I came on as CTO of PP, our entire company was less than 10 people. Now, more than 4 years later, the dev team alone is over 35 and the company is almost 90 people. I, along with the rest of the management team, wanted to find someone who had the experience to help the team grow even further so we could tackle ever larger problems and build better software, faster. I’m so pleased that we were able to find and bring on someone as smart and talented as Tatum. The future is bright.

Intern Recap Summer 2014

Each summer, Paperless Post welcomes a few interns on to our engineering team. Our interns have varied backgrounds, but are all interested being developers and working at a tech company/startup. They go through an intensive education program consisting of talks, lunches, meetings with teams and team leads, and then spend the majority of the summer working on a single team developing code. This was our 5th year of the program and we invited our interns to share some thoughts on their experiences!


My name is Richard. I am a student currently attending University of Waterloo studying Computer Science. I have a passion for mobile development and see myself working in that field in the future. I joined the Platform team in the role of iOS developer. I helped the team develop a lot of new features for the iPhone and iPad applications.

When I began my internship, my first task was to familiarize myself with the team’s codebase. Prior to working there, I had experience with iOS development from my previous internship so I was already familiar with a lot of the codebase and was immediately ready to start tackling some issues. To start off, I was given some bugs and really small features to fix and build. This was to help me become more familiar with the codebase. My first major task was to build a “Welcome To Paperless Post” screen, shown when a user signs up through the application. This welcome screen appears immediately after the user’s account is created, and along with displaying a welcoming message, it gives the user the option to be sent emails about updates. One really cool thing about the Welcome screen is that on the iPhone, it blurs out the background and adds the message on top of it.

My next major task was to implement an automatic reminder scheduler to guests about an event. The automatic reminder is used to remind guests about the event that is coming up. Upon opening the automatic reminder, the user can type in a message and set up a time and date for this message to be sent to all their guests. The user can also send themselves a sample email to see how the message would look.

Throughout my internship, I learned to use a lot of design patterns and coding techniques, and overall I expanded my knowledge in Objective-C. While I was building the Welcome screen, I learned how to interact with the API backend, as this was needed for the email updates sending option. I was really fascinated by the interactions, and this was the first time, I used Objective-C and interacted with something outside of Objective-C. While building the Welcome screen, I also learned a really cool pattern, called categories. Categories are used to extend the functionality of a class. This made my changes to the codebase a lot cleaner and a lot easier to understand and follow. When I wanted to add extra functionality to an already huge class, I made a category based off of that huge class, and thus made those extra functionalities I added more easier to find and readable.

While I was building the automatic reminder, I learned about another really cool pattern I learned, is attributed strings. More specifically, TTTAttributedLabels, which is a customized version of attributed strings. Attributed strings are strings that can be customized, as in certain substrings of the string can be of a different size, font, color, etc than other substrings. Along with all those functionalities, TTTAttributedLabels also adds clickable substrings and links. This made it easier if you have a string and you only want one word of that string to be clickable.

In a lot of these features I have built, I was asked to write unit tests to test their functionalities making sure that it is all working fine. This was all new to me, as I have never built unit tests for iOS, however I quickly learned that making unit tests in iOS is really similar to making unit tests in Python (for web) or in Java (for Android), in which there is a set up and a tear down, that gets called before each test.

I really enjoyed the iOS weekly meetings. In these meetings, the iOS developers join together to listen to one of us talk about a design pattern or coding technique. In these talks, I learned even more about design patterns and coding techniques, and after each one of them, I couldn’t wait to try them out.

Working in Paperless Post was a completely new experience for, with a hip and really relaxing environment. This is also the first time I worked in New York. My team has taught me a lot and given me a lot of really useful feedback that has definitely made me a much better developer, and the experience I gained here is something that will carry on with me in the future.


Hi, my name is Hyoju and I’m a student at Brown University. This summer, I worked with the Host/Account Management (HAM) team. I decided to join Paperless Post because I was impressed by how their product integrates technology and design, beautifully transforming a traditional experience into a digital one. This was my first developer internship and my background was not in Ruby or Rails, however, it didn’t matter. Paperless Post was very willing to not only help me familiarize with their product and processes, but also with the general languages and tools.

During the first few weeks, we were greeted with a series of talks and lunches, quickly making us comfortable with the company. My first tasks were small bug fixes (e.g. optimizing queries, changing copies and constraints), which were completed through pair programming with Gordon, Dev Lead for HAM team. Pair programming allowed me to see how to navigate through the massive web app and familiarize with the coding styles. Then, my tasks evolved into adding small and large features to cart, account and admin pages.

My most interesting tasks were helping with the pricing and discounting method changes. For pricing, I was able to change the method with which we apply price adjustments to our card products. For discounting, I helped change the way promo codes are applied. Currently, promo codes can only be applied on an entire order with various restrictions, but with the change, they will be able to be more freely applied on specific SKUs. Both tasks were difficult to approach at first, as there were a lot of layers of code to go through, making it difficult to figure out all the places the change would affect. However, it was very interesting to dig into that part of the app and I really appreciated that I was given the responsibility to work on changes that affect an integral part of the business model.

I also worked on building various administrator tools and fixes to allow the User Support team to help users more effectively. Such tasks included adding a quick view to keep track of card delivery statuses, building a dropdown to update review statuses, and allowing to batch update guest names.

Being an intern at Paperless Post was an amazing experience. I was not only able to explore and contribute to a live web app, but was able to learn something new every day. From front-end additions to testing, I was able to work on tasks covering various aspects of the app, allowing me to fully explore the product. Though I’ve only been with the company for 3 months, I really enjoyed being part of such a fast growing company and truly felt myself growing with it.


My name is Rick and I am a fourth year student studying the wonders of Computer Science at Waterloo. I came on board the internship program at Paperless Post as part of my school’s co-op program. I was assigned to the Create team which is mainly responsible for everything having to do with the homepage, paper browser, and the create tool. After doing a quick tour of the office, all of the new hires went through a training program spanning two weeks where we were introduced to the internal dev tools and the architecture of our product. This was awesome, and the time it took to get myself pushing branches and merging into production was only one day and a half. It just goes to show how refined the process is for new people to get started. Much better than some previous companies I have worked for.

I started working on some small bugs and fixes, like adding one letter to the end of a word or making a new link open in a new tab. While these tasks seemed easy, I was not familiar with the codebase and had no previous experience with Ruby or Haml. The codebase has a fairly straightforward structure, but without understanding how everything was hooked up, these simple tasks ended up taking up a lot more time. My coworkers were always more than happy to help me and I remember them saying, “we might have headphones on, but that doesn’t mean you can’t approach us.”

My work was very standalone and while most of the team was working on larger branches, I was getting faster at taking care of the smaller things. It got to the point where I no longer needed to ask people “where can I find #{some_code}?” or “how do you make it appear on a new line like %this?” or “what does the ? mean?”

In the middle of the summer I was told that I’d be working on a huge feature. It was exciting to know that I would add a whole new level of code with another colleague of mine to offer something to our customers that would make them extremely happy. It was great to know that I was making a difference.

Aside from work, we had plenty of team outings and events, with short talks every other Friday from individuals about something development related, to company lunches and internship parties. I even took the canteen floor to demonstrate to the entire company some of my gloving skills!

As a co-op, I wanted to learn things, but not just things like the stuff they teach you in school. I want to know what companies are doing to deal with scaling issues, what’s hot in the software world, and where everything is going. Ever since the first day I came here, I have learned mountains about things I had no clue about before I arrived. I’m really grateful for the internship experience that Paperless Post has given me. The office is very nice, the people are even better, and it’s located in New York City.

If you think you’d be a good fit at Paperless Post, check out our current openings and apply online!

Paperless Post Tech Talks: Chrys Wu

Paperless Post’s series of tech talks continues next month with a talk by Chrys Wu. Chrys will be speaking about “The Role of Data & Design In Engaging With An Audience” on Tuesday, August 5th at 7pm at the Paperless Post offices.

Chrys Wu, a journalist, strategist, coder and cook, works with businesses to deepen connection to people through community-building strategy, user-centric design and code.

She is currently Developer Advocate for The New York Times, where she leads internal and public-facing projects that advance and highlight the technology made by New York Times Developers.

If you would like to attend the talk, please RSVP and make sure to bring a photo ID to check in with building security.

About Paperless Post Tech Talks

Paperless Post Tech Talks are our chance to bring developers and artists whom we admire into our New York office to talk and share knowledge about their work with our team and the larger New York tech community. They are open to the public but RSVP is required as space is limited. There will be time to talk and mingle with the other attendees and the speakers over craft beer and snacks.

Paperless Post Tech Talks: Ken Perlin

Paperless Post’s series of tech talks continues this month with a talk by Ken Perlin. Ken will be coming to speak about “Early Experiences and Current Influences in Computer Graphics” on Thursday, June 26th at 7pm.

Ken is a professor in the Department of Computer Science at NYU and the Founding Director of its Media Research Lab, as well as the Director of the Games for Learning Institute. He invented Perlin noise and was involved in the development of many early influential computer graphics techniques.

As a System Architect for computer-generated animation at Mathematical Applications Group he worked on the movie Tron and has received an Academy Award for Technical Achievement. We’re thrilled to have him come talk to us about the path he’s taken and connections between the earliest days of computer graphics and today.

If you’d like to attend the talk, please RSVP and make sure to bring a photo ID to check in with building security.

About Paperless Post Tech Talks

Paperless Post Tech Talks are our chance to bring developers and artists whom we admire into our New York office to talk and share knowledge about their work with our team and the larger New York tech community. They are open to the public but RSVP is required as space is limited. There will be time to talk and mingle with the other attendees and the speakers over craft beer and snacks.