At Parabola we really like music: every Wednesday you’ll find the team listening to a different collaborative playlist based around a theme. Recent features have included: breakup songs, hot girl summer, and music suggestions for my upcoming wedding.

If you’re a music lover, going to concerts is the best way you can show support for musicians. Even better: go to concerts and buy a t-shirt; merch sales are a great way to directly support artists you care about.

Spotify has great support for discovering local concerts for bands you already love, but what about bands you haven’t discovered yet? If you really want to see a concert this week, but aren’t sure who to see — you’re a bit out of luck.

That’s why we decided to build Discover Local. Modeled after Spotify’s popular Discover Weekly playlist, Discover Local is a weekly playlist of music from artists who are performing in your city that week. Every Monday morning you can throw it on, find a new artist to love, and see them play live before the end of the week!

The best part? We built the entire product with zero code using Parabola and Webflow!

This article takes a look at how we actually made it happen, but if you just want to see the finished product you can click here to check it out.

Overview

The high level program design is as follows:

• Local concert information comes from Songkick
• Tracks and playlists are sourced from Spotify
• Everything gets mashed up and organized in Parabola
• Content is pushed directly to Webflow

Seems simple, right? For the most part it is, but there are a few sticking points we’ll take you through below.

Deep Dive: Weekly Spotify Playlist for Local Shows

The first chunk of the program fetches upcoming concerts from Songkick. We use a simple Google Sheet to keep track of which cities we want to build playlists for, and to keep track of the date one week from now.

Mapping City Names to Metro Ids

Our first task is to map the name of each city to its corresponding Songkick metro id; metro ids are unique identifiers that ensure Songkick always knows which Washington it’s talking about (there are 88 of them!).

To do that, we use a Parabola step you’re going to see quite a lot throughout this article: API Enrichment. API Enrichment makes a web request against a URL you specify once for each row of data you pass to it. The step’s other superpower is that it can dynamically substitute values from your data into the URL (or a POST body). If you want Parabola to insert a value from your data into the URL, all you have to do is type the column name wrapped in curly braces, e.g., {Your Data}, and we’ll take care of the rest.

So in this case we have a list of cities, and we’re going to make a request to Songkick’s location search API once for each.

https://api.songkick.com/api/3.0/search/locations.json?query={Cities}&apikey=YOUR_API_KEY

Songkick sends back multiple possible locations per input, but for now we’re just going to assume the first one returned is the one we want. We use the deduplicate step to trim our data so we only have one metro per input city, and now we’re ready to fetch concerts!

Fetch Concerts in Each City

We use the API Enrichment step again to ask Songkick for all concerts taking place over the next week in the specified metro area. This API call requires pagination, and you can check out the flow template to see how you set that up in Parabola.

https://api.songkick.com/api/3.0/metro_areas/{api.metroArea.id}/calendar.json?apikey=YOUR_API_KEY&per_page=50&max_date={Date}

It turns out there are a ton of concerts every week, and each concert has multiple performers. To keep this simple, though, we’re only going to keep the top twenty from each city, and we’re only going to consider artists with first or second billing. We do that by first sorting the data, filtering by billing index, and finally using the dedupe step again to retain only the twenty most popular concerts for that week.

Source Songs from Spotify

So at this point we’ve got a list of twenty artists in each of a handful of cities around the world.

Note: the program works with any city that Songkick & Spotify support, but to keep it simple we’ve only seeded a few on Discover Local right now. Let us know if you want to see a playlist for your city!

We need to map the artist names that we got back from Songkick to their unique identifiers in Spotify (just like we did with city names and metro ids!). We do this by calling Spotify’s search API with the artists’ names:

https://api.spotify.com/v1/search?q={Arist Name}&type=artist

Again, there are multiple artists with the same name. We’re just going to assume that the one with the most followers is the one we want: we sort by popularity, and dedupe again, letting Parabola know that we want to keep at most two duplicates.

Note: Spotify APIs use OAuth — so you’ll need to set that up before interacting with Spotify in Parabola. You’ll want to use the Authorization Code Flow. If you get stuck, we have a very well-written guide to talk you through it. Shout-out to Brian.

Now we want to fetch each artists’ top tracks:

https://api.spotify.com/v1/artists/{api.id}/top-tracks?country=US

Easy!

Compose Playlists

With tracks in hand, all that’s left is to compose them into playlists and send them over to Spotify.

We can use Parabola’s group by step to concatenate all the track uris into a single column, and now we’re ready to use an API Export to sync our new playlists to Spotify.

https://api.spotify.com/v1/playlists/{Playlist Id}/tracks?uris={Tracks}

But wait — what if the playlist for a particular city doesn’t exist yet? What about the tracks that are still in the playlist from last week?

Here’s where things get cool.

We need to implement a little create/delete procedure for our Spotify playlists before we can ship them:

• If a playlist doesn’t exist yet, it should be created
• If a playlist exists, we should clear its contents to make way for new songs

Note: Until recently it was pretty tricky to do something like this in Parabola, but one of our rockstar engineers, Michelle, made it so that API Exports can now block and wait until an external update completes before proceeding!

At a high level what we want to do is partition the to-be-created playlists into two groups: those that exist in Spotify already and those that don’t. We first join the to-be-created playlists with a list of playlists fetched directly from our company’s Spotify account, then we branch the program down two paths. We use two row filters to ensure that only relevant rows make it into each branch.

For playlists that don’t exist yet, we run an API Export to create them:

https://api.spotify.com/v1/users/{id}/playlists

Body

{
     "name": "{Playlist Name}",
     "public": {public}
}

Then we re-fetch the list of playlists from our company’s account so that we get back the playlist ids for those that were just created.

For playlists that need to be cleared, we use an API Enrichment to fetch the list of tracks currently in the playlist, concatenate them like we did for the new tracks just above, and then use a different API Export to clear them:

https://api.spotify.com/v1/playlists/{api.id}/tracks

Body

{
   "tracks":[
      {
         "uri":"{api.track.uri (concat)}"
      }
   ]
}

Send Playlists to Spotify

Now that our to-be-created playlists have either been created or cleared, it’s finally time to send them to Spotify!

To do that we’ll use one last API Export, and send the concatenated track list we created in the previous step over the wire:

https://api.spotify.com/v1/playlists/{Playlist Id}/tracks?uris={Tracks}

Note: there is another chunk to this program that takes the playlists and pushes them into Webflow’s CMS. We haven’t had a chance to document that bit yet, but you can click this link to create a new flow with it and explore how it works for yourself!

Conclusions & Future Work

We hope you enjoy listening to Discover Local — maybe you find a new favorite artist and make your way to their show!

If you’ve made it this far, you likely also find it cool that we were able to build this with absolutely no code in a couple of afternoons.

Building in Parabola is really fun and empowering. There is no app to download or libraries to install; you don’t even have to pay us — just jump in and get started!

We handle all the infrastructure pieces like scaling up/down, network I/O, and scheduled executions. As a builder, you can focus on what is actually important: the logic of your program.

Our team in San Francisco is laser focused on making Parabola a place for people to build awesome stuff. If you have ideas for features we should support, want to showcase something you built, or want a job — get in touch.

Powered by Parabola #2: Weekly Spotify Playlist for Local Shows was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

It was the end of May, and I had a simple question to answer: how much money were we spending on advertising each day across our three main channels?

At the time, the solutions I came up with were:

1. Spend a bunch of time each day manually downloading reports, sum the figures, and update a spreadsheet
2. Ask our already-strapped engineering team to write code and create a dashboard
3. Pay for and set up an expensive, overkill third party SEM-management tool
4. Build it myself with Parabola

I suppose you can guess what I did. The whole thing took me a couple hours and twenty seven Parabola steps. The flow runs every day at 8am PDT and updates a Google spreadsheet with the previous day’s ad spend. When our CEO asks me how much we spent on ads in July I can have the answer in a few seconds. It cost the company $0, and I have a work product I can feel good about!

Below I’ll go into more detail on exactly how I made this work in Parabola, but you can also visit our site play around with or customize my solution to suit your needs.

Getting access to the ad platform APIs

The hardest part of building this was just getting access to the ad platforms’ APIs. We’re currently running ads on Google, Facebook and Quora, so I needed access to all those services:

• The Facebook Ads API was by far the simplest of the three to get started. I created an Ads Application from this page, added the Marketing API to it and was able to make calls to retrieve my account data right away.
• The Quora Ads API is in a private beta, so we reached out via the form on their site.
• For Google Ads, I had to follow the instructions here. In short: sign up, wait for approval, and then get going.

The other slightly complicated piece here was that both Google and Quora require authentication via OAuth 2.0. Parabola supports OAuth 2.0 now, but I still had to copy/paste a bunch of stuff and that created ample surface area for silly errors.

Fetching data from the ad platform APIs

Once I had access to the ad platform APIs, I needed to figure out what URLs to call to get the data I wanted. Parabola makes it trivially easy to extra whatever performance data you need from these APIs, but in my case I just wanted ad spend info from the last 30 days sliced by date.

Each of the APIs does this a bit differently:

Facebook:

GET https://graph.facebook.com/v3.3/act_{YOUR ACCOUNT NUMBER}/insights?date_preset=last_30d&time_increment=1&access_token={YOUR ACCESS TOKEN}

Quora:

GET https://api.quora.com/ads/v0/accounts/YOUR_ACCOUNT_ID?granularity=DAY&presetTimeRange=LAST_30_DAYS

Google:

POST https://googleads.googleapis.com/v1/customers/{YOUR ACCOUNT ID}/googleAds:search

POST body:

{"query" : "select segments.date, metrics.cost_micros from customer where segments.date during last_30_days"}

Compiling the spend report in Parabola

Once I had the data in Parabola, compiling the report was actually really easy.

Since each API delivered slightly different data, I made a few transforms to account for things like converting micro cents to dollars, standardizing the column names/positions, and trimming extraneous columns. Then I used the join step to merge all three data chunks together based on the date (YYYY-MM-DD format).

My main goal with this project was to log our daily ad spend in a Google Sheet so that I could reference it easily, but I also wanted historical data so I could assess things like how our June spend compared to our July spend.

The problem is that Parabola doesn’t have built in support for appending values to a Google Sheet yet. So I got the opportunity to implement the append functionality myself with Parabola.

To do this, I first partitioned my data into three chunks:

• Older data that was in the spreadsheet but was no longer being sent back from the ad platforms
• Recent data that was both in the spreadsheet and being sent back from the ad platforms
• Brand new data that was being sent back from the ad platforms but not in the spreadsheet yet

For each case, I told Parabola how I wanted it handled:

• Old data would be passed through just as it was found in the source sheet
• For data in both places, I’d replace the spreadsheet data with the most data from the ad platforms (in case there was an outage/error/whatever)
• New data can only come from the ad platforms

Finally, I used a table merge to squash the three data partitions on top of each other, and synced it to the spreadsheet.

If you want to see more about how this example and others actually work in Parabola, read more on our site. If you have feedback or questions, shoot me an email!

How I built a single view of multi-channel ad spend with Parabola was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

Powered by Parabola: Travel Newsletter

When I joined Parabola in May I was eager to explore different use cases. Having just left Google’s hotel search team, travel was still top of mind.

I decided to build a weekly newsletter centered on an unusually cheap flight in the near future. In addition to the travel destination, I wanted my newsletter to have a few things: links for flight booking, hotel recommendations, things to do, restaurants, descriptions, and photos.

A good chunk of my time early on in this project was spent searching Google for high quality APIs that didn’t require too much paperwork to sign up.

Here is the set of services I ended up using:

• Flight information from Skyscanner via RapidApi.
• Destination photos from Unsplash, ranked using Everypixel’s stock photo scoring API.
• Weather information from DarkSky.
• Hotel and restaurant info from the Michelin Guide API.
• Attraction information from the Google Places API.
• Hotel and attraction photos from Google Image Search via Google’s Custom JSON Search API.
• Descriptions of the destination city and the attraction from Wikipedia.

Using Parabola, I was able to blend data from all these sources into a useful, aesthetically pleasing newsletter.

As someone who can write code, but isn’t a software engineer, it was very gratifying to build this application in Parabola. I was able to focus on what was important for the project: the data sources, the content, etc., without having to fight with the kinds of technical roadblocks that would have normally waylaid me on a project like this.

You can find the final implementation here. Feel free to go check it out, and when you’re ready, you can read on for a detailed description of how I built it.

If you have feedback, questions, or want to see your program featured in this series, shoot me an email! I’m excited to see what you’ll build. 🤙

Deep Dive: Travel Newsletter

I started with a simple Google Spreadsheet that holds a few key pieces of information: the departure date (seven days from now), the return date (14 days from now), and a list of candidate countries for the program. Google Sheets keeps these dates updated automatically for me.

Calling Skyscanner

My first major task was to get flight prices from Skyscanner. I found an API that allowed me to search for flights between an origin airport (SFO in this case), and an entire country! I could input a query for flights from SFO to Japan and get back loads of prices for flights to all major airports in Japan.

To actually call the Skyscanner API, I used Parabola’s API Enrichment step.

The API Enrichment step enables connecting and getting data from just about any API by filling in a few form fields.

It makes a web request to the specified URL once for each row of input. It can also replace parts of the URL dynamically based on the input. In my case that part was essential: I needed to call Skyscanner a bunch of times for all the different SFO -> Country combinations.

If this sounds hard, it’s not! You’ll see below how easy it is to get this set up in Parabola.

The RapidApi endpoint I needed to access looks like this:

https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/browsequotes/v1.0/{country}/{currency}/{locale}/{originplace}/{destinationplace}/{outboundpartialdate}

You can see there are placeholders available to input a country, currency, location, origin, destination, and outbound/inbound dates. This is where the dynamic substitution comes in handy. I specified some of the values by hand (country, currency, locale, and originplace), and had Parabola fill in the rest dynamically.

After processing the input values from my Google Sheet, I am able to pass them to my API Enrichment step in the format you see on the left.

I’ve got a list of destinations (formatted in the way Skyscanner likes) each with a depart/return date. Parabola will go through every line of this input and call the Skyscanner API.

As I mentioned above, the API Enrichment step also lets you use a special curly brace notation to swap out parts of the URL with values found in your input data. In my case this was super handy because I needed to call the Skyscanner API once for each of the potential travel destinations.

In Parabola, I configure the API Enrichment step so that the URL looks like this:

https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/browseroutes/v1.0/US/USD/en-US/SFO-sky/{Skyscanner}/{Depart}?inboundpartialdate={Return}

Parabola will replace {Skyscanner} with the value found in the column of that name — the destination. It replaces {Depart} and {Return} with the matching values from those columns.

After a few seconds my program gets the response back from Skyscanner: a huge list of possible flights from SFO to destinations all around the world. Now I need to sort the results that came back from Skyscanner to find the cheapest prices.

Once I identified the destination, it was time to build a whole newsletter around it!

Calling Wikipedia

I use Wikipedia data twice in this program: it’s the source of both the city and the attraction descriptions. The steps are the same in both cases, though, so I’ll just explain it once here.

The best way I found to do it is:

• Search for articles matching the topic of interest using Wikipedia’s search API
• Assume the first article is the one you want. This works reasonably well for notable things (e.g., Paris, Eiffel Tower) but almost certainly breaks down for more niche interests
• Retrieve article summary from the summary endpoint

In Parabola, that procedure looks like this:

First I searched for articles matching the cheap destination I had selected using API Enrichment. In Parabola, that ends up looking like this:

https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={Destination}&utf8=true&srlimit=1&format=json

Wikipedia returns the first article, then I make one more API Enrichment call to get a nice article summary:

https://en.wikipedia.org/api/rest_v1/page/summary/{api.title}

Easy, right?

Hotels & Restaurants

Originally the newsletter only pulled in restaurant data from Yelp, but when adding in hotels I needed to find another data source.

Most big travel companies do have APIs, unfortunately there was lots of paperwork involved to start using them. Turns out the Michelin Guide offers a fairly rich API, and actually has better international restaurant coverage than Yelp, so I ended up using it for both hotels and restaurants!

The procedure for fetching hotels and restaurants is similar; I’ll only be writing up the hotels section because it’s a bit more involved.

For this newsletter, I decided to request the most expensive five star hotel in the destination. Since the flights are so cheap, you can afford to splurge on the hotel, right?

I use the API Enrichment step again to fetch the top result from Michelin — that’s easy — but Michelin doesn’t include any images for their hotels (they do for restaurants).

For hotels, I needed to get images from elsewhere. I decided to fetch the images from Google Image Search using a Custom Search Engine. You can create a new CSE by following this link. Note that you’ll want to enable two key options for this to work as expected: [1] switch Image Search on, and [2] switch on Search the Entire Web.

Once you’ve set up your CSE, calling it in Parabola is straightforward. In my case, I just took the first image that came back and moved along.

https://www.googleapis.com/customsearch/v1?key=YOUR_KEY_HERE&q={api.datasheets.name}%20{CityName}%20rooms&searchType=image

Points of Interest

I decided to fetch points of interest from the Google Places API.

Specifically, I chose to call the Find Place API as I only really needed one, and based on some manual testing was reasonably happy with Google’s default ranking.

https://maps.googleapis.com/maps/api/place/findplacefromtext/json?key=XX&input=points%20of%20interest&inputtype=textquery&locationbias=circle:5000@{lat},{lng}&fields=name&language=en

The snippet above shows how I called the Google Places API from Parabola’s API enrichment step. I passed in a few things:

• input = ‘points of interest’ (url encoded). We tested this query and it seems to generally do the right thing in most cities around the world.
• locationbias = circle:3000@{lat},{lng}. This searches a circle 3km around the latitude and longitude we provide. In this case we’ve already called the Google Geocode API to get the latitude and longitude of our destination city.
• fields=name. This keeps our cost down as we’re only requesting the name of the attraction and not any of the paid SKUs.

Once I get the attraction back from Google, I fetch its description from Wikipedia using the same procedure from before.

Destination Photos

What good is a travel inspiration email without beautiful imagery to accompany it?

I decided to use Unsplash as the source of my newsletter’s hero photo because (1) Unsplash photos are free and open source, and (2) they are often very beautiful.

By now you’re probably familiar with this part: we need to use API Enrichment to fetch Unsplash photos for the newsletter destination. Parabola will replace {Destination} with whatever [city, country] pair is featured in this week’s newsletter.

https://api.unsplash.com/search/photos?page=1&query={Destination}&client_id=X

Unsplash returns a bunch of metadata along with each image, but I had trouble identifying a heuristic among those attributes that reliably revealed the “best” image; I tried sorting by number of photo likes, number of user likes, etc.

Then I stumbled across a cool API for ranking stock photos. For a small fee, this API lets you pass in a set of images and have a machine learning model score each one on its aesthetic merit.

https://api.everypixel.com/v1/quality?url={api.urls.raw}

Once my program gets the scores back, it sorts them by score and filters down to the top result.

Weather

I also wanted to help readers get a sense for what the weather would be like in the newsletter destination. Since the trip doesn’t start for seven days after the email sends, though, the extended forecast probably won’t be very accurate. Instead, I chose to display the forecast for the next week. Although not the same dates a reader would be traveling, I thought this should give folks a sense of the weather in the region.

I fetched the weather forecast from DarkSky’s forecast endpoint. Again, I use API Enrichment to make the call, and use curly brace substitution to pass in the latitude and longitude of the intended destination. In the snippet below, you’d replace ‘XX’ with your API key.

https://api.darksky.net/forecast/XX/{lat},{lng}

Things got a little bit tricky here, though. As you’ve seen Parabola, can replace items inside curly braces with values from the corresponding column. In the email template I had created, I wanted to share four days worth of weather. So I had created a bunch of placeholders that look like: {High1}, {Date1}, {Summary1} and so on.

DarkSky was giving me back several rows of data, and I needed four columns of data.

To make this happen, I trimmed the results down to four rows and numbered them using the row numbers step. Then I used the unpivot step to duplicate what would eventually be my column names so that I had one cluster per original row of weather data.

Type    | Value
-----     -------
Date    | Mon 24th Jun
Summary | Possible drizzle overnight.
High    | 93
Low     | 79

...  and so on

What would eventually become the curly brace names in my email were currently in the type column. Next, I merged that column with the row numbers I had created earlier so I end up with {Date1}, {High2}, etc. Finally, I pivot the data so the column names I created would actually be the columns in my data.

Date1        | Summary1                   | High1 | Low1 | Date2
Mon 24th Jun | Possible drizzle overnight | 93    | 79   | Tue 25...

At this point I finally had the data I needed neatly bucketed in all the places it was supposed to go. I was ready to send my email!

Composing and Sending the Email

I decided to use a SendGrid campaign template as the starting point for my email, but you can use whatever email HTML editor you feel most comfortable with.

Here’s an approximation of what it looks like in the SendGrid builder. Parabola will take all the curly brace stuff and replace it with the corresponding values that I created in my data above.

                      {DestinationDescription}
             {Date1}                             {Date2}
        {High1} // {Low1}                   {High2} // {Low2}
            {Summary1}                          {Summary2}

Those curly-brace substitutions are pretty powerful:

Bangkok is the capital and most populous city of Thailand. It is known in Thai as Krung Thep Maha Nakhon or simply Krung Thep. The city occupies 1,568.7 square kilometres (605.7 sq mi) in the Chao Phraya River delta in central Thailand, and has a population of over eight million, or 12.6 percent of the country's population....

        Mon 24th Jun                            Tue 25th Jun
         91 // 79                                 92 // 92
     Possible drizzle...                      Possible light...

They work with any text, links, whatever. So after we download the HTML from SendGrid’s editor we update all the links to the appropriate curly-brace values, e.g., {DestinationImage}, {RestaurantImage}, etc. This lets Parabola substitute the image URLs with the images we fetched throughout this program.

<img src="{DestinationImage}">

Now it’s time to send the email! I did one big join to bring together all the difference pieces that had been built up to that point: things to do, restaurants, hotels, photos, descriptions, and flight booking info. Then I passed the output off to SendGrid for delivery.

Conclusion

I hope this write up was clear, fun and informative! Again, you can check out the complete program, play around with it, or use it as a starting point for your own work by heading to our examples page.

Some of the API documentation I linked to in this article can seem a bit overwhelming, but its actually not as complicated as it looks. Parabola does most of the heavy lifting, and if you get stuck there are a couple of resources we’ve put together to help you. Of course, you can also always reach out to us directly via email or the Intercom chat widget on our site.

If you enjoyed this, keep an eye out for part two in the series. I’ll be exploring a Parabola program I built that generates a weekly playlist full of songs from musicians performing in your local area.

How I Built a Weekly Travel Newsletter in Parabola was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

A common refrain lately is that everyone should learn how to code. Computer science should be a core part of middle and high school curriculums, recent college grads who made the mistake of studying liberal arts should immediately enroll in developer bootcamps, and the only reason jobs feel scarce among the working class is that they haven’t morphed themselves into software engineers.

We disagree. Coding as it’s defined today is difficult to learn and even harder to do well. Not only that, but specialization in other roles is more important than ever. Nonetheless, the ability to code does confer some incredible benefits in terms of productivity and output.

This is exactly why we’re building Parabola. Think of it as a way to apply the benefits of coding without having to learn how to “code” as it’s defined today. But before we dive into exactly what Parabola is, let’s take a step back and look at the current state of the world.

Coding is difficult

Now certainly, learning how to code could be a fantastic opportunity. But getting to the point where you’re familiar with and can use modern programming languages/frameworks for something real is hard. It requires more time and commitment than acknowledged by those recommending learning to code. There’s a steep learning curve, entirely new mindsets to adopt, and a large amount of overhead to stay up-to-date. If you want to be a professional software engineer, the investment is sensible. For the rest of us, though, the effort isn’t worth it just to be able to use computers more efficiently.

Specialization is important

Taking a step back, specialization of jobs has been a key factor in the increasing prosperity of the world. Most people don’t grow their own food, make their own clothes, build their own furniture, or record their own music (although if you do all of those things, we should hang out!). Instead, a few people specialize in each of those tasks and then sell their work to the rest of us, who specialize in other tasks. The result is work gets done by people who are actually experts in their field. Both quality and quantity increase.

In the business world, we do the same thing. We split our companies into marketing, sales, product, operations, and more. Further still, we have specialties and sub-specialties within each of those departments. In marketing, for example, some people specialize in outbound email campaigns, while others optimize search engine marketing, and still others manage social media. This specialization makes sense. Most companies probably don’t want their finance team running their Twitter account, or the marketing team ensuring GAAP-compliant accounting. Why then should people in any of those departments be expected to spend their time learning to code?

Software is leverage

On the other hand, coding does have a lot of benefits. A person’s “leverage” is the amount of output they can get from a given period of time. People who know how to code have a huge amount of this kind of leverage, and can get a lot of output from each unit of time they put in. This is why software engineers get paid so much.

This leverage primarily results from three factors. Code can:

• Automate manual work
• Make working with large data sets possible
• Package complex tasks up into simple programs for others to use

These three factors are surprisingly powerful, and are why the most valuable companies in the world are now tech companies.

Shouldn’t you be able to do these things without learning to code?

Yes. The ability to code gives engineers superpowers because of how much leverage they have on their time. Parabola gives everyone else the same superpowers.

Now let’s be clear. Parabola doesn’t do everything a software engineer can. We’ve designed Parabola with a set of trade-offs, but they’re trade-offs we think you’ll really like and appreciate.

Using an entirely drag-and-drop interface, Parabola enables everyone to create repeatable flows that interact with a variety of other tools.

That process where you export 5 different CSV files, run a SQL script someone made you once but you don’t know how it works, copy and paste it all into Excel, write a bunch of VLOOKUPS (or INDEX/MATCH if you’re an excel ninja) to merge it all together, stare at it to make sure you pasted correctly, delete columns, find/replace a bunch of things, and then 10 other manual steps before you send the results to 5 different people by email? You can build that all into Parabola once, and then it can be scheduled to run whenever you want without any more manual work from you.

But that’s just scratching the surface of what Parabola can do. Parabola can also work with large data sets that would crash a spreadsheet tool, and your flows can even be packaged up and shared with other people. We have customers using Parabola to build custom marketing attribution reports, extend the functionality of their CRM and marketing automation tools, and even monitor fleets of ground moisture sensors to fine-tune irrigation schedules.

The best part? There’s no infrastructure to maintain, no code to write, and no waiting on engineers or IT to help you. You can sign up for free right now and immediately start reducing busywork and increasing your leverage.

If you’d like to learn more, you can visit our website at parabola.io or reach out to us at hi@parabola.io.

Not everyone needs to learn how to code was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

Parabola gives non-coders the building blocks they need to create complex data flows in a drag and drop interface. Our logo was designed to reflect that: take a bunch of basic shapes and combine them in an intelligent way to create something greater than the sum of the individual pieces.

I’ve always loved the concept, but the first version of the logo looked just a little too complex, and became unreadable at smaller sizes. Because of these issues, we decided to refine it.

Removing the excess overlap

The main problem with the original logo, particularly at smaller sizes, was that there were just too many color transitions created by the overlapping shapes. The B was the worst of them all with 7 different regions. We decided on a goal of keeping each character to a maximum of three regions.

An additional benefit of limiting ourselves to three regions per character was going to be getting rid of the two extra colors required for the B. These two extra blues did not exist anywhere else in our app, so we wanted to get rid of them entirely (we were also updating our color palette at the same time, which is why the blues are different).

We were able to clean up the P, R, and B and refine their shapes to only use a maximum of three regions and two unique colors. We also tweaked the L to line up with the other letters.

Some final tweaks

We widened the As to make them less spiky, and made the spacing between all characters equal, except for the P & A. The shape of those characters required kerning, so we shrunk the padding to zero between them.

The Result

We’re super excited with how it turned out! Widening the As and adding more space between characters resulted in a slightly wider logo, but so far it’s worked great with our UI. Check out the final result below.

Thanks for reading! If you’re interested in learning more about Parabola, check out our website here. You can sign up for a 14-day free trial, no credit card required.

Refining our Logo, Before and After was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

How would you take your data from Stripe, dedupe, clean, and transform it based on a bunch of rules, enrich it with Clearbit, and push the results to Salesforce and Geckoboard? What would you do if you had to repeat the process every month, week, or day?

“Do it manually, or hire a developer.” — Everyone

Parabola was built to solve the headache of data processes like this. You can build unique data flows in minutes that pull data from other apps, transform that data in almost any way imaginable, then pipe it to its destination. The best part is, once you’ve built your flow once, you can set it to run automatically on any schedule. And you can do all of this without looping in a developer.

It’s a complex product, and it took a ton of design iterations to get to where we are today. Here are some lessons we’ve learned trying to make this complex product feel simple and intuitive.

Maintain an effective information architecture 👁

Information Architecture (IA) is the art and science of organizing and labelling websites and software to support usability and findability. Wikipedia

Maintaining an effective IA is one of those balancing acts that is so hard to get right, so hard to maintain, especially when there are multiple teams working on different features with little communication between them. It takes a lot of persistence to not only improve, but also just maintain the effectiveness of your information architecture as your feature set grows.

Your IA falls into one of these three categories…

Too complex: If a product is too complex at first glance, it can feel overwhelming to the user as their eyes dart back and forth looking for the thing they’re currently interested in.

Too simple: If a product is too simple at first glance, with the meat of the functionality buried, it can be cumbersome to use as you drill in and out of different parts of the product.

Just right: Your users can immediately get a sense for what they can do with your product, how they can do it, and they can get started with zero cognitive friction.

How to find your “just right” information architecture

You need to empathize with your customers, make their problems your problems, and you need to have a feedback loop in place that enables you to be constantly learning from them. Finding your just right information architecture doesn’t happen overnight, it more often comes after tons of iterations.

This earlier prototype of Parabola shows just how many things we had competing for your attention. When new users landed on this screen for the first time, they were blasted with five separate panes, two of which had three separate tabs, a bunch of colors that didn’t really tell them much, and zero guidance for how to get started.

This pretty much looked like Xcode, which was built for developers. Since we’re trying to create a visual programming language that anyone can use, we knew we needed to simplify. Here’s Parabola today:

We cut out all but one of the panes, simplified the objects on the canvas, and added tooltips to guide you along your journey to becoming an activated user.

New features are exciting, and risky 👹

As new features are added, you should analyze just how important they are to the product as a whole, and slot them into your IA accordingly. Every new feature you add steals attention from its adjacent features, so you need to be sure the trade-off is worth it. They can also change how your users think about your product, sometimes in unintended ways.

With Parabola, we’ve ripped out a lot of stuff in order to bring attention back to the features that support our key value proposition. When we added charts and graphs, our users’ perception of our product went from a “tool to automate data processes” to a “tool to create data visualizations”.

Which is not what we wanted at all. So after spending a lot of time building the feature and launching it to users, we ripped it out. Sometimes ripping out features can be just as important as adding new ones.

The goal is, though, to not have to. Which brings me to my next point.

Data is your best friend 🔢

It’s cheap and easy to send a survey to validate your ideas with user feedback. It’s expensive and slow to build something that your users don’t want.

Use analytics data, user tests, and surveys to gather as much information as you can to effectively shape your roadmap to align with what you and your customers want your product to become.

“In God we trust, all others bring data.” W. Edwards Deming

Some tools I recommend

Segment: Pipe data to any analytics tool
FullStory: Watch how users interact with your product
TypeForm: Send out surveys to your customers

Be consistent with your visuals 🎨

Visual design is often perceived as creating pretty illustrations and pixels, but it goes far beyond that. Creating a clean visual design language that is enforced across every component in your product will make everything feel more consistent and digestible. Every new UI element and visual style or color you introduce adds more cognitive load for the user, so it should be done sparingly.

At Parabola, we have one shared Sketch library (what’s that?), which has every component we use in our app and all their different states. When we update a component in the library, it updates in all of our designs automatically.

This is also why we decided to bundle our marketing site and app together in one repository. We want to ensure that as our users transition from our marketing site to the app, the visual language remains exactly the same (because they use the same code!). We don’t have to worry about styles changing in one repository but not in another.

Final thoughts

There’s no silver bullet when it comes to designing a great product. Great products are the result of thousands of improvements, hundreds of iterations, and talking to customers every step of the way.

If you’re interested in Parabola, sign up for a 14-day free trial, no card required.

Some lessons learned designing a complex product like Parabola was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you’re a sales leader or SDR, you’ve felt the soul-crushing time drain of maintaining and updating Salesforce or another CRM with lead status, communication channels, profile data, and so much more. It’s excruciating.

Add in the frequently manual process of compiling reports on a regular basis, and it’s no wonder why sales teams spend a good chunk of their quarter not selling. In fact, sales teams, on average, spend almost a third of their time updating CRMs, managing data, and creating reports. That’s time that could have been spent prospecting, contacting leads, giving demos, or closing deals.

Your sales team spends one-third of their time not selling.

Even if you’re lucky and your sales tools already have integrations with your CRM, data frequently doesn’t quite line up. Reports for a specific metric never seem to have the right data.

To make matters worse, if you want to automate anything in Salesforce, you are going to need a consulting agency (read: far too expensive for what you get) or dedicated engineering time (read: a waste of resources).

We feel your pain, and that’s why we’ve built Parabola.

Parabola enables anyone to work with and automate their data as effectively as an engineer without needing spreadsheets or code.

Quickly and easily connect to any data, no engineers required

With the increasing number of tools utilized by most sales teams, it’s becoming common to have data that is incomplete, incompatible, or inconsistent. Trying to connect disparate date is usually a task limited to overworked development teams. Parabola has an ever growing list of integrations (including common databases) that allow you to pull in data from anywhere in a few clicks, without any code required.

Pull in data from anywhere in a few clicks, without code.

With data integrations and automation, you can:

• Join Google Analytics data with Stripe data, to see which blog articles bring in the most enterprise customers.
• Connect Mailchimp campaign data with both Salesforce and analytics data stored in Redshift to get a complete picture of what a user is doing on and off your site, before trying to up-sell them.
• Use custom logic and references to data from other services to automatically update Salesforce accounts and leads.
• Create a shared data pipeline that can be used by multiple users for reporting, analysis, or normalization.
• Send out live sales reports synthesized from multiple sources to your team.
• Automatically clean new data before it enters your CRM.
• Update Salesforce leads to Do Not Contact using the results from an opt-out link in automatic emails, or from a form on your site.
• Update a lead to an opportunity automatically when a lead performs some sort of action visible in analytics, or through a form.
• Check leads without Opportunities Set against your new contacts, to catch inconsistencies. Then automatically update the leads to have Opportunities Set.
• Automatically update Salesforce via Google Forms used by AEs and SDRs for quick data entry.

Reclaim your day with automation

Most of the hassle of a powerful CRM like Salesforce comes from keeping records up-to-date. Why are you spending a third of your week updating Salesforce and generating custom reports?

Automation takes care of the menial tasks that feel manual and slow, and gets a team back to doing what they do best — selling. Using Parabola’s Automation, you can recapture enough time to help your sales team blow past quota and still make it to happy hour.

Use Parabola to Automate your manual sales data tasks today

Give Time Back to your Sales Team with Codeless Automation was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

When it comes to automated email marketing, the underlying data is directly tied to a campaign’s success. With good data, services like Mailchimp, Active Campaign, Hubspot, Marketo, and others can do a great job of sending personalized marketing emails to targeted consumers.

The power of good email marketing automation lies not in the volume or scheduling of the emails, but in the level of testing, iteration, and ultimately personalization.

In order for email marketing to be successful, you need to:

Collect and understand the data to be used for personalization

Understand and measure the goal of each campaign

Then you can build an automatic email marketing machine that reaches qualified leads and delivers personalized messages that resonate. This is how you can quickly expand your marketing efforts and see an instant return.

Parabola drastically speeds up and simplifies this data legwork. Here are the steps to deal with multiple data sources, automate your data management, and track custom marketing goals that update your strategy:

1. Collect and unify your data

Collecting raw data for automated email marketing is easy. You probably have any number of the following:

A lead magnet on your site to draw in new visitors and passively collects emails.

A lead chat solution like Intercom to collect pieces of data about leads as they talk to you.

An email newsletter or blog sign up form

An integration with Clearbit to deliver data enrichment

A CRM like Salesforce containing a table of leads and their statuses

All of this data lives in separate locations, each with its own unique environment and set of rules. This data becomes a powerful marketing asset when you combine it into a complete data picture.

Using Parabola, anyone can import and combine data from any of these sources. Parabola then enables anyone to clean, dedupe, merge, filter, enrich, and add logic to the data, all without touching a line of code or dealing with a fragile spreadsheet.

For example, with Parabola, you could automate a retargeting campaign for leads who previously downloaded your lead magnet, but never converted:

Import your Salesforce leads

Filter down to those who have not converted in the last 60 days

Import your lead magnet email list

Join the two lists, only keeping those who who exist in both

Import your Clearbit data for those emails

Use that to add in names, company sizes, industry, and more

Export that data to your email campaign tool

Parabola has created a list of people to retarget and some information to use in the email personalization. Generally, using first names (instead of full names) increases open rates, so use the Name Parser Object to pull out first names.

2. Automate the data

Unified data can be used to create personalized emails that will attract and convert leads.

You could repeat the aforementioned steps with each segment of leads that you are targeting, but that could take hours to pull each new data set and run the flow manually. Your time should be spent on analyzing, testing, and iterating, so why not automate the data processing?

Once a flow is set up, schedule Parabola to automatically refresh the data coming in and then pass it through the transformations in your flow. Set it to run automatically every day, or just when you have a new campaign to send out. The data always stays fresh.

3. Take your personalization to the next level

Basic company data is not that impressive for automated email marketing. How about sending to multiple email addresses, some who are CC’ed, and having the salutation automatically include all the first names, with proper punctuation? That would be far too time consuming to do manually without Parabola.

For example, when marketing a service that charges per seat — it would be common to target adjacent employees in the company who are not yet using your service. Obviously, a hand-typed email would be best, but sales and marketing superstars don’t have time for that.

Use a combination of data manipulation objects to build a flow that will combine the first names of all of the recipients at a company, join them with commas, and insert an “and” before the final name. Even add “(CC’ed)” after each name whose email is in the CC column of the table.

This can be done automatically and intelligently, checking if there are leads who are not closed, and who have colleagues already using the service. When someone’s colleague signs up for the newsletter months from now, they will receive an extremely personalized email — automatically.

4. Custom goal tracking without an engineer

Most marketing automation tools have some form of goal tracking feature, but let’s be honest, it never works like you want it to. Many times the utility of goals is limited by the tool.

To maximize your efficacy, you need custom goals. Ty to set a goal that x% of the people who receive the campaign should sign up on a business-tier plan within 30 days, and they should invite at least one colleague to join them. How could that goal be set without involving an engineer?

With Parabola create this complex goal by simply branching off of the flow, and adding in a few more data sources:

Data from Salesforce on who has invited users

Data from Salesforce on who is on which plan

Take that data and do the following:

Join it with the existing table of leads who received the campaign

Filter it for leads who are still within the 30 day success window

Total it up

The results are custom goal success metrics. You could even plot them on a chart to track performance over time.

Automatic email marketing is a foundation for growth

Companies grow by generating continuous demand and then capturing and nurturing leads. Adding automation and improving the efficiency of the top of the funnel is a great way to grow your business while simultaneously freeing yourself up to tweak other areas of your sales and marketing engine.

☞ Improve your marketing automation with Parabola today☜

Automating the Rest of Your Marketing Pipeline was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

Many forms ask for a contact’s full name (rather than first and last). This can help streamline data entry and improve form completion rates. However, it can cause problems when you want to use just a specific part of the name. For example, using merge tags to send custom emails. “Hi John Smith” doesn’t feel as personal as “Hi John”.

Use the Name Parser Recipe here.

Parabola’s Nam Parser Object is specifically created to extract any part of a name. It can extract any of the following name types into new columns:

• Salutation
• First Name
• Middle Name
• Last Name
• Suffix
• Full Name

Get started with the Name Parser Recipe and split your name data easily.

Become a data superstar

Parabola enables anyone with any level of data or technical knowledge fully transform, analyze, and visualize any dataset. Without using spreadsheets or code.

For more recipes and data solutions, check out our Recipe Page.

How to extract and separate names within a dataset was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.

One of the most common reasons that our customers use Parabola is to combine and clean multiple email datasets. It is not uncommon for companies to have multiple CRM’s, survey software, blog based email capture, and more — these different sources make it difficult to find a single source of truth.

By combining multiple pre-configured recipes, you can quickly and easily create a complex email list cleaning flow that is flexible for future data. Export the final list to an email marketing service with personalization information such as company name and recipient first name.

Each step of this tutorial is available as a standalone recipe on our recipe’s page. These can be instantly deployed into a new Parabola project with one click.

Recipes Used in This Tutorial

1. Joining Data
2. Separating Name Fields
3. Scoring Leads
4. Summarizing Data
5. Automatic Filtering

Bringing together multiple data sources

Problem: Merging multiple data sets together is one of the most common but also frustrating data tasks. In Excel you may be used to using a series of VLOOKUP or INDEX(MATCH()) functions. If you know SQL, you can use a JOIN.

Parabola Solution: You can combine any number of data sources with a couple clicks using the Join Object or the Multiple Join Object. New data connected to the Object will automatically joined.

View The Joining Data Recipe

1. Connect your data to Parabola via CSV, Google Sheets, a database connection, etc
2. Use the Join Object to join your data based off of a common attribute, in this case email addresses
3. Define the type of join (Left, Inner, Outer)

Cleaning names to isolate just the first and last name

Problem: Many forms ask for a contact’s full name (rather than first and last). This can help streamline data entry and improve form completion rates. However, it can cause problems when you want to use just a specific part of the name. For example, using merge fields to send custom emails. “Hi John Smith” doesn’t feel as personal as “Hi John”.

Parabola Solution: You can extract any part of the a name with with the Name Parser Object and split them into new columns. The Name Parser can even handle prefixes, suffixes, and multi-part names.

View The Separating Name Fields Recipe

1. Select the Name Parser Object and connect data to it
2. Choose the name parts to separate into new columns

Score leads to quickly assess their value

Problem: When sending emails to leads, you may have 10 or more contacts at a given company, but you don’t want to email all of them. To keep the sales process working effectively, you probably only want to email the top few contacts at each company based on lead scoring metrics.

Parabola Solution: You can automatically score leads against any criteria using the Scoring Object, such as the title that the contact holds. Quickly aggregate and export high value contacts with this data.

View The Scoring Leads Recipe

1. Select the Scoring Object and connect data to it
2. Create rules that govern the scoring, such as matching the contents of a column

Group by an attribute to summarize the data associated with it

Problem: Large tables of data can be difficult to understand at a glance. Rolling them up into summary tables makes them much more understandable. In Excel, you might use something like a pivot table, or in SQL you might use a GROUP BY.

Parabola Solution: You can group by any attribute and display useful information such as the average scores for each company by using the Group By Object. This is also useful for quickly aggregating transaction or sales data per region and sales rep.

View The Summarizing Data Recipe

1. Select the Group By Object and connect the scoring data to it
2. Select “Avg”, using the score as the data field and the company as the group by column

Filter columns to prepare an export to CSV for upload elsewhere

Problem: Filtering data in Excel is highly manual/time-consuming, and can lead to confusing errors when viewers are able to change their filter settings. Adding new data to the file may also require the filters to be reset.

Parabola Solution: You can create a separate branch of your data flow that has only the relevant columns or rows for export by using the Column Filter Object or Row Filter Object. As new data passes through the flow, it is automatically filtered using the existing criteria.

Automatic Filtering Recipe

1. Select the Column Filter Object or Row Filter Object and connect your data to it
2. Select the columns/rows to keep or those to remove

Exporting your data

Connect any data flow to the CSV Export Object to download the data. Alternatively, export the data to Google Sheets.

1. Add the CSV Export Object and connect the filtered data to it
2. Click Export to CSV

Become a data superstar

Parabola enables anyone with any level of data or technical knowledge fully transform, analyze, and visualize any dataset. Without using spreadsheets or code.

For more recipes and data solutions, check out our Recipe Page.

Join, clean, and export your email data was originally published in Parabola.io on Medium, where people are continuing the conversation by highlighting and responding to this story.