How To Design and Develop APIs That Developers Will Love to Use

If you are building an API, it’s more than likely going to be consumed by another developer. Your API must be easy to understand and easy to use. Below are a few tips that can help you design an API that other developers will love.

Endpoint Path Must Be a Noun

The endpoint paths should ideally contain nouns and avoid verbs. The HTTP verbs are sufficient in telling the consumer the purpose of the endpoint.

#javascript

What is GEEK

Buddha Community

How To Design and Develop APIs That Developers Will Love to Use
Chloe  Butler

Chloe Butler

1667425440

Pdf2gerb: Perl Script Converts PDF Files to Gerber format

pdf2gerb

Perl script converts PDF files to Gerber format

Pdf2Gerb generates Gerber 274X photoplotting and Excellon drill files from PDFs of a PCB. Up to three PDFs are used: the top copper layer, the bottom copper layer (for 2-sided PCBs), and an optional silk screen layer. The PDFs can be created directly from any PDF drawing software, or a PDF print driver can be used to capture the Print output if the drawing software does not directly support output to PDF.

The general workflow is as follows:

  1. Design the PCB using your favorite CAD or drawing software.
  2. Print the top and bottom copper and top silk screen layers to a PDF file.
  3. Run Pdf2Gerb on the PDFs to create Gerber and Excellon files.
  4. Use a Gerber viewer to double-check the output against the original PCB design.
  5. Make adjustments as needed.
  6. Submit the files to a PCB manufacturer.

Please note that Pdf2Gerb does NOT perform DRC (Design Rule Checks), as these will vary according to individual PCB manufacturer conventions and capabilities. Also note that Pdf2Gerb is not perfect, so the output files must always be checked before submitting them. As of version 1.6, Pdf2Gerb supports most PCB elements, such as round and square pads, round holes, traces, SMD pads, ground planes, no-fill areas, and panelization. However, because it interprets the graphical output of a Print function, there are limitations in what it can recognize (or there may be bugs).

See docs/Pdf2Gerb.pdf for install/setup, config, usage, and other info.


pdf2gerb_cfg.pm

#Pdf2Gerb config settings:
#Put this file in same folder/directory as pdf2gerb.pl itself (global settings),
#or copy to another folder/directory with PDFs if you want PCB-specific settings.
#There is only one user of this file, so we don't need a custom package or namespace.
#NOTE: all constants defined in here will be added to main namespace.
#package pdf2gerb_cfg;

use strict; #trap undef vars (easier debug)
use warnings; #other useful info (easier debug)


##############################################################################################
#configurable settings:
#change values here instead of in main pfg2gerb.pl file

use constant WANT_COLORS => ($^O !~ m/Win/); #ANSI colors no worky on Windows? this must be set < first DebugPrint() call

#just a little warning; set realistic expectations:
#DebugPrint("${\(CYAN)}Pdf2Gerb.pl ${\(VERSION)}, $^O O/S\n${\(YELLOW)}${\(BOLD)}${\(ITALIC)}This is EXPERIMENTAL software.  \nGerber files MAY CONTAIN ERRORS.  Please CHECK them before fabrication!${\(RESET)}", 0); #if WANT_DEBUG

use constant METRIC => FALSE; #set to TRUE for metric units (only affect final numbers in output files, not internal arithmetic)
use constant APERTURE_LIMIT => 0; #34; #max #apertures to use; generate warnings if too many apertures are used (0 to not check)
use constant DRILL_FMT => '2.4'; #'2.3'; #'2.4' is the default for PCB fab; change to '2.3' for CNC

use constant WANT_DEBUG => 0; #10; #level of debug wanted; higher == more, lower == less, 0 == none
use constant GERBER_DEBUG => 0; #level of debug to include in Gerber file; DON'T USE FOR FABRICATION
use constant WANT_STREAMS => FALSE; #TRUE; #save decompressed streams to files (for debug)
use constant WANT_ALLINPUT => FALSE; #TRUE; #save entire input stream (for debug ONLY)

#DebugPrint(sprintf("${\(CYAN)}DEBUG: stdout %d, gerber %d, want streams? %d, all input? %d, O/S: $^O, Perl: $]${\(RESET)}\n", WANT_DEBUG, GERBER_DEBUG, WANT_STREAMS, WANT_ALLINPUT), 1);
#DebugPrint(sprintf("max int = %d, min int = %d\n", MAXINT, MININT), 1); 

#define standard trace and pad sizes to reduce scaling or PDF rendering errors:
#This avoids weird aperture settings and replaces them with more standardized values.
#(I'm not sure how photoplotters handle strange sizes).
#Fewer choices here gives more accurate mapping in the final Gerber files.
#units are in inches
use constant TOOL_SIZES => #add more as desired
(
#round or square pads (> 0) and drills (< 0):
    .010, -.001,  #tiny pads for SMD; dummy drill size (too small for practical use, but needed so StandardTool will use this entry)
    .031, -.014,  #used for vias
    .041, -.020,  #smallest non-filled plated hole
    .051, -.025,
    .056, -.029,  #useful for IC pins
    .070, -.033,
    .075, -.040,  #heavier leads
#    .090, -.043,  #NOTE: 600 dpi is not high enough resolution to reliably distinguish between .043" and .046", so choose 1 of the 2 here
    .100, -.046,
    .115, -.052,
    .130, -.061,
    .140, -.067,
    .150, -.079,
    .175, -.088,
    .190, -.093,
    .200, -.100,
    .220, -.110,
    .160, -.125,  #useful for mounting holes
#some additional pad sizes without holes (repeat a previous hole size if you just want the pad size):
    .090, -.040,  #want a .090 pad option, but use dummy hole size
    .065, -.040, #.065 x .065 rect pad
    .035, -.040, #.035 x .065 rect pad
#traces:
    .001,  #too thin for real traces; use only for board outlines
    .006,  #minimum real trace width; mainly used for text
    .008,  #mainly used for mid-sized text, not traces
    .010,  #minimum recommended trace width for low-current signals
    .012,
    .015,  #moderate low-voltage current
    .020,  #heavier trace for power, ground (even if a lighter one is adequate)
    .025,
    .030,  #heavy-current traces; be careful with these ones!
    .040,
    .050,
    .060,
    .080,
    .100,
    .120,
);
#Areas larger than the values below will be filled with parallel lines:
#This cuts down on the number of aperture sizes used.
#Set to 0 to always use an aperture or drill, regardless of size.
use constant { MAX_APERTURE => max((TOOL_SIZES)) + .004, MAX_DRILL => -min((TOOL_SIZES)) + .004 }; #max aperture and drill sizes (plus a little tolerance)
#DebugPrint(sprintf("using %d standard tool sizes: %s, max aper %.3f, max drill %.3f\n", scalar((TOOL_SIZES)), join(", ", (TOOL_SIZES)), MAX_APERTURE, MAX_DRILL), 1);

#NOTE: Compare the PDF to the original CAD file to check the accuracy of the PDF rendering and parsing!
#for example, the CAD software I used generated the following circles for holes:
#CAD hole size:   parsed PDF diameter:      error:
#  .014                .016                +.002
#  .020                .02267              +.00267
#  .025                .026                +.001
#  .029                .03167              +.00267
#  .033                .036                +.003
#  .040                .04267              +.00267
#This was usually ~ .002" - .003" too big compared to the hole as displayed in the CAD software.
#To compensate for PDF rendering errors (either during CAD Print function or PDF parsing logic), adjust the values below as needed.
#units are pixels; for example, a value of 2.4 at 600 dpi = .0004 inch, 2 at 600 dpi = .0033"
use constant
{
    HOLE_ADJUST => -0.004 * 600, #-2.6, #holes seemed to be slightly oversized (by .002" - .004"), so shrink them a little
    RNDPAD_ADJUST => -0.003 * 600, #-2, #-2.4, #round pads seemed to be slightly oversized, so shrink them a little
    SQRPAD_ADJUST => +0.001 * 600, #+.5, #square pads are sometimes too small by .00067, so bump them up a little
    RECTPAD_ADJUST => 0, #(pixels) rectangular pads seem to be okay? (not tested much)
    TRACE_ADJUST => 0, #(pixels) traces seemed to be okay?
    REDUCE_TOLERANCE => .001, #(inches) allow this much variation when reducing circles and rects
};

#Also, my CAD's Print function or the PDF print driver I used was a little off for circles, so define some additional adjustment values here:
#Values are added to X/Y coordinates; units are pixels; for example, a value of 1 at 600 dpi would be ~= .002 inch
use constant
{
    CIRCLE_ADJUST_MINX => 0,
    CIRCLE_ADJUST_MINY => -0.001 * 600, #-1, #circles were a little too high, so nudge them a little lower
    CIRCLE_ADJUST_MAXX => +0.001 * 600, #+1, #circles were a little too far to the left, so nudge them a little to the right
    CIRCLE_ADJUST_MAXY => 0,
    SUBST_CIRCLE_CLIPRECT => FALSE, #generate circle and substitute for clip rects (to compensate for the way some CAD software draws circles)
    WANT_CLIPRECT => TRUE, #FALSE, #AI doesn't need clip rect at all? should be on normally?
    RECT_COMPLETION => FALSE, #TRUE, #fill in 4th side of rect when 3 sides found
};

#allow .012 clearance around pads for solder mask:
#This value effectively adjusts pad sizes in the TOOL_SIZES list above (only for solder mask layers).
use constant SOLDER_MARGIN => +.012; #units are inches

#line join/cap styles:
use constant
{
    CAP_NONE => 0, #butt (none); line is exact length
    CAP_ROUND => 1, #round cap/join; line overhangs by a semi-circle at either end
    CAP_SQUARE => 2, #square cap/join; line overhangs by a half square on either end
    CAP_OVERRIDE => FALSE, #cap style overrides drawing logic
};
    
#number of elements in each shape type:
use constant
{
    RECT_SHAPELEN => 6, #x0, y0, x1, y1, count, "rect" (start, end corners)
    LINE_SHAPELEN => 6, #x0, y0, x1, y1, count, "line" (line seg)
    CURVE_SHAPELEN => 10, #xstart, ystart, x0, y0, x1, y1, xend, yend, count, "curve" (bezier 2 points)
    CIRCLE_SHAPELEN => 5, #x, y, 5, count, "circle" (center + radius)
};
#const my %SHAPELEN =
#Readonly my %SHAPELEN =>
our %SHAPELEN =
(
    rect => RECT_SHAPELEN,
    line => LINE_SHAPELEN,
    curve => CURVE_SHAPELEN,
    circle => CIRCLE_SHAPELEN,
);

#panelization:
#This will repeat the entire body the number of times indicated along the X or Y axes (files grow accordingly).
#Display elements that overhang PCB boundary can be squashed or left as-is (typically text or other silk screen markings).
#Set "overhangs" TRUE to allow overhangs, FALSE to truncate them.
#xpad and ypad allow margins to be added around outer edge of panelized PCB.
use constant PANELIZE => {'x' => 1, 'y' => 1, 'xpad' => 0, 'ypad' => 0, 'overhangs' => TRUE}; #number of times to repeat in X and Y directions

# Set this to 1 if you need TurboCAD support.
#$turboCAD = FALSE; #is this still needed as an option?

#CIRCAD pad generation uses an appropriate aperture, then moves it (stroke) "a little" - we use this to find pads and distinguish them from PCB holes. 
use constant PAD_STROKE => 0.3; #0.0005 * 600; #units are pixels
#convert very short traces to pads or holes:
use constant TRACE_MINLEN => .001; #units are inches
#use constant ALWAYS_XY => TRUE; #FALSE; #force XY even if X or Y doesn't change; NOTE: needs to be TRUE for all pads to show in FlatCAM and ViewPlot
use constant REMOVE_POLARITY => FALSE; #TRUE; #set to remove subtractive (negative) polarity; NOTE: must be FALSE for ground planes

#PDF uses "points", each point = 1/72 inch
#combined with a PDF scale factor of .12, this gives 600 dpi resolution (1/72 * .12 = 600 dpi)
use constant INCHES_PER_POINT => 1/72; #0.0138888889; #multiply point-size by this to get inches

# The precision used when computing a bezier curve. Higher numbers are more precise but slower (and generate larger files).
#$bezierPrecision = 100;
use constant BEZIER_PRECISION => 36; #100; #use const; reduced for faster rendering (mainly used for silk screen and thermal pads)

# Ground planes and silk screen or larger copper rectangles or circles are filled line-by-line using this resolution.
use constant FILL_WIDTH => .01; #fill at most 0.01 inch at a time

# The max number of characters to read into memory
use constant MAX_BYTES => 10 * M; #bumped up to 10 MB, use const

use constant DUP_DRILL1 => TRUE; #FALSE; #kludge: ViewPlot doesn't load drill files that are too small so duplicate first tool

my $runtime = time(); #Time::HiRes::gettimeofday(); #measure my execution time

print STDERR "Loaded config settings from '${\(__FILE__)}'.\n";
1; #last value must be truthful to indicate successful load


#############################################################################################
#junk/experiment:

#use Package::Constants;
#use Exporter qw(import); #https://perldoc.perl.org/Exporter.html

#my $caller = "pdf2gerb::";

#sub cfg
#{
#    my $proto = shift;
#    my $class = ref($proto) || $proto;
#    my $settings =
#    {
#        $WANT_DEBUG => 990, #10; #level of debug wanted; higher == more, lower == less, 0 == none
#    };
#    bless($settings, $class);
#    return $settings;
#}

#use constant HELLO => "hi there2"; #"main::HELLO" => "hi there";
#use constant GOODBYE => 14; #"main::GOODBYE" => 12;

#print STDERR "read cfg file\n";

#our @EXPORT_OK = Package::Constants->list(__PACKAGE__); #https://www.perlmonks.org/?node_id=1072691; NOTE: "_OK" skips short/common names

#print STDERR scalar(@EXPORT_OK) . " consts exported:\n";
#foreach(@EXPORT_OK) { print STDERR "$_\n"; }
#my $val = main::thing("xyz");
#print STDERR "caller gave me $val\n";
#foreach my $arg (@ARGV) { print STDERR "arg $arg\n"; }

Download Details:

Author: swannman
Source Code: https://github.com/swannman/pdf2gerb

License: GPL-3.0 license

#perl 

An API-First Approach For Designing Restful APIs | Hacker Noon

I’ve been working with Restful APIs for some time now and one thing that I love to do is to talk about APIs.

So, today I will show you how to build an API using the API-First approach and Design First with OpenAPI Specification.

First thing first, if you don’t know what’s an API-First approach means, it would be nice you stop reading this and check the blog post that I wrote to the Farfetchs blog where I explain everything that you need to know to start an API using API-First.

Preparing the ground

Before you get your hands dirty, let’s prepare the ground and understand the use case that will be developed.

Tools

If you desire to reproduce the examples that will be shown here, you will need some of those items below.

  • NodeJS
  • OpenAPI Specification
  • Text Editor (I’ll use VSCode)
  • Command Line

Use Case

To keep easy to understand, let’s use the Todo List App, it is a very common concept beyond the software development community.

#api #rest-api #openai #api-first-development #api-design #apis #restful-apis #restful-api

Marcelle  Smith

Marcelle Smith

1598437740

A Simple Guide to API Development Tools

APIs can be as simple as 1 endpoint for use by 100s of users or as complex as the AWS APIs with 1000s of endpoints and 100s of thousands of users. Building them can mean spending a couple of hours using a low-code platform or months of work using a multitude of tools. Hosting them can be as simple as using one platform that does everything we need or as complex as setting up and managing ingress control, security, caching, failover, metrics, scaling etc.

What they all have in common are three basic steps to go from nothing to a running API.

Each of these steps has its own set of tools. Here are some I’ve used and popular alternatives.

Design

REST is the most popular API interface and has the best tooling. Our design output for REST services always includes an OpenAPI specification. The specification language can be tricky to get right in JSON (how many curly brackets?) or YAML (how many spaces?) so a good editor saves a lot of time.

Four popular ones are:

I’ve only used Swagger and Postman but both Insomnia and Stoplight look interesting. All of them offer additional functionality like documentation, testing and collaboration so are much more than just specification generators.

#api #apis #api-development #restful-api #rest-api #development-tools #app-development-tools #developer-tools

Tracking a Developer’s Journey From Documentation Visit

If your business model involves selling to developers, you probably have already realized that much of the traditional processes and metrics applicable to traditional enterprise sales or consumer marketing don’t work. Specifically, selling to developers usually means attracting them to your platform and helping them succeed in building something, whether that’s a new app, integration, or automating an internal process. Getting developers to adopt your platform can be daunting and requires investment in product, onboarding and developer experience, and documentation. However, there are few tools product managers and developer relations leaders can leverage to measure and improve that experience.

Web and mobile analytics tools like Mixpanel and Amplitude can only measure activity on the website itself, yet most developer platforms price on what happens with the API, not via website activity. On the other hand, most API monitoring tools can only track infrastructure metrics like requests per minute and CPU utilization without any context of the user. To accurately measure your adoption and conversion funnel, you need to track usage across your entire platform from initial ad click and sign up, to what a new developer does with your API.

What is the developer-first marketing strategy

Most developer-first platforms have a B2D (business2developer) go to market strategy which is uniquely different from B2C companies which drive consumer adoption, but also different from B2B companies who maintain large sales forces to push their solution to other businesses. In reality, B2D sits somewhere in the middle between B2B and B2C.

B2D is like B2C in that:

  • Self-service signups and credit card payments takes priority over sales demos and contract negotiation
  • Low-cost acquisition channels like SEO-optimized content, SEM, and partnerships are prioritized over large and expensive sales development teams sending emails.
  • Because almost everything is self-serve and online, you can be very data-driven in terms of product metrics focused over just focusing on 1:1 relationships.

B2D is also like B2B in that:

  • The developer still works at a company who is buying to solve a pain rather than an individual looking for the latest gadget or online hangout spot.
  • Sales processes can still be complex involving multiple stakeholders and require technical validation.
  • Developers are still humans implementing a complex solution and may need high-touch dedicated support vs B2C where support is super transactional handling password resets and returns.

Building a cross-platform funnel across web and API

API product managers can focus on any number of initiatives at any given time, whether that;s API features, pricing and packaging, or top of the funnel acquisition. In order to know which area to focus, you should map out your _entire_funnel from very first ad click to a fully activated customer paying and referring other customers. The beginning of your funnel might start on your website as a visitor signs up to use your API. However, once they created an API key, much of the magic happens on the API side rather than the web side. Many developer platforms build their business model around usage-based pricing, which means your revenue is correlated to API usage, not website usage.

Funnel StageSourceDescriptionWhat to look forSigned UpWebsiteThe first step a developer makes is to show interest in your platform. For developer tools, this usually means signing up and generating an API key.Your analytics solution should be tracking which channel the user came from using UTM parameters, referrer tracking, etc along with which page drove the signup.Made first API CallAPIThis is a huge milestone as many signups never reach this stage. The developer was able to understand your API and give it a spin.Monitor TTFHW (Time to First Hello World) and conversion rate. You should continue looking at which channels drive the most activations.Made over 100 API CallsAPIAfter a 100 or so API calls, you could consider the developer “active”, in that they built a real integration rather than just testing with Postman or CurlA low conversion rate from the last step could imply difficulties with your SDK or unclear integration steps.Approaching Free LimitsAPIMost API products are priced on usage. In order to become a paying customer, they need to exceed some limit.If very few long-term “active” developers exceed their limits,then you may need to optimize your packaging and pricing.Converted to PayingWebsiteCongrats! You now have paying customers.Most developers have more than one value metric they price on. Keep an eye on which ones are driving paid conversions.Evangelized your APIWebsiteAre developers sharing and discussing your platform online?By adding a mechanism to track referrals, you can see which channels and mediums are performing the best. A complete analytics platform can track UTM parameters and things like referring domain. With a mechanism to generate unique links pere customer, you can also track which types of customers share the most.

API Adoption Funnel

Linking web with API activity for users and companies

Business2developer go to market models have elements of both B2C and B2B and involve both individual developers and also companies or accounts. It also involves cross-platform tracking across web and APIs. This can complicate accurate funnel and conversion reporting. Do you track an individual user sign up funnel or do you track companies who integrated and use the API? What happens if a developer clicks on an AdWord and signs up using his or her GitHub account but doesn’t do anything. If the person invited a colleague to do integration, then that person may only be attributed to “direct traffic” or “invite referral” depending on your marketing attribution. We need to still attribute the successful integration to an AdWord click.

One way to solve this is mapping out a 4x4 grid to track:

Developers active on APICompanies active on APIDevelopers active on websiteCompanies active on website

Not all API platforms will follow this model and may fill some boxes with a don’t care. For example, many APIs don’t care or track which developer is accessing the API, yet it’s important to understand which company is using the API. In this case, we want to track the following:

_Not Applicable_Companies active on APIDevelopers active on websiteCompanies active on website

Solving the cross-platform tracking

In order to solve this, analytics platforms like Moesif link everything through user ids and company ids regardless of the sessions. Your API and website should use the same identities regardless of the platform for accurate reporting. By modeling companies as groups of users, the linking can be simplified. This provides flexibility in picking and choosing whether to track usage only at the user-level, only at the company-level, or both for the API and website separately.

While having permanent identifiers are great, sometimes we don’t have all information available when the API call or user action is logged. To solve for these cases, we leverage the website session token or API key to uniquely identify the person and company. An alias table that links both session tokens to user/company ids and also API keys to user/company ids enable end to end funnel tracking.

Closing thoughts

Tracking usage and retention accurately is critical in 2020 as leadership shifts from a growth at all costs to efficient growth driven from product optimizations. You can no longer just measure vanity metrics like pageviews and signups. Instead, you should be measuring the entire funnel and understand the inputs that impact each stage. How does changes to your pricing and packaging modify your conversion rates from active developer to converted paying customer.

#api management #developer marketing #developer relations #developer experience #api adoption #developer advocacy #developer advocate #api product #api program #developer evangelism

How to Market to Developers with Paid Marketing

At Moesif, we primarily market to developers and other technical audiences like product managers and developer relations teams looking to make their own developer platform successful. Getting developers to adopt your API or tool is hard and requires heavy investment in experimentation and measurement in order to achieve the results you’re looking for. At the same time, much of the online advice you hear for B2C or B2B marketing simply won’t work when marketing to developers. This article outlines much of the findings we’ve seen as we grew Moesif from 0 to now over 5,000 companies including Deloitte, UPS, and Radar.

What makes developer marketing hard

Before jumping into things you should be trying, let’s review what’s so special and hard about marketing to developers. Most developer-focused companies are founded and led by developers themselves, so you would think figuring out things like product marketing should be easy right? After all, you’re just marketing to yourselves. Just like any audience, there is no single developer persona.

Accurate measurement is difficult

Fast and iterative experimentation is critical to recoup any investment in paid ads. If you’re not diligently tracking your metrics, you can easily run up your cost per acquisition (CPA). However, what do you actually measure against for a developer tools company? Accurate attribution can be complicated since for many developer-tools, the majority of the value and magic your product creates is via an API or integration, not via a mobile or web app. This means a user who signed up and clicked around your website isn’t necessarily a converted user. Yet, there is some intent based on the content or areas of the product a user is looking at. For most developer-first companies, we recommend looking at a metric such as developers who made their first API call. Later, you can define additional funnel stages such as developers who made more than X transactions through your API or developers who used Y different features. Additional complication comes from attributing back to the marketing channel since now you have to instrument both your website to track the acquisition channels a developer went through and then linking that to what the developer did with your API.

Targeting is hard

Most social ad networks are designed to target general consumers based on personal demographic data, not developers. You can target consumers with these networks with simple Yes or No filtering. Such as Does the person live in San Francisco or Is the person aged between 18 and 24 years old. This means if you’re a pizza shop in San Francisco, it’s relatively easy to set up Facebook ads to target college students aged 18 to 24 who live in or around San Francisco. This demographic may be ideal late nite pizza customers.

For developer’s there is no single “is developer” demographic that can be answered via a simple Yes or No question. You could attempt something like _Is their college degree Computer Science”, but software engineering is a career with a variety of educational paths and does not always require a computer science degree. Even if you could match on a person’s title, software engineering is an ambiguous role with varying responsibilities. Some engineering develop embedded systems for cars and drones, some software engineers are focused on building internal data analytics infrastructure, others are integrating billing APIs.

Many developer tools are in horizontal markets targeting a variety of markets rather than singling out a specific industry, but they solve a specific problem. Like enterprise sales, this means you need to target the right developer who will have a use for your devtool and champion it internally.

  • If you’re building a billing API, you need to target the guru in charge of billing infrastructure
  • If you’re building analytics tools, you need to target the product manager or engineering manager that’s the de facto analytics expert
  • If you’re building a new tool for docker, you need to target the devops master who happens to also be a Linux master.

Many stakeholders

The art of selling to developers is similar to most complex enterprise sales processes which have a multitude of stakeholders involved. For devtools, the number of stakeholders can be even more than traditional SaaS since you may have architecture review, security sign off, implementation, etc. This is because many times developers are checking out your tool or product for a corporation, not just for themselves. Handling these complications can be rolled into your marketing plan, rather than waiting until last minute objection handling.

Developers are skeptical

Technical audiences are by nature skeptical. They love to build things, not buy services. This creates inherent biases as they are exposed to third party solutions. Due to internal political struggles, some developers may have resentment or bias against sales and marketing teams. This makes direct outreach less effective. While it does work for certain top-down sales strategies such as for selling security software to CISOs, many devtools are trying to get an individual developer to first adopt the tool and then grow from there.

Paid inbound marketing

One of the most effective ways to attract developers to your platform (rather than filling their email box) is with inbound marketing. Inbound marketing is the art of attracting or pulling in developers to adopt your platform rather than forcibly pushing your platform on to them. There are a variety of techniques for inbound marketing from SEO to referrals, but the focus of this article is paid ads.

Why is inbound great for developers

As mentioned, developers are usually skeptical of traditional marketing activities. Whether this is an email from a SDR that is two paragraphs too long or a huge banner that says “Sign up now.” Being numbers-driven, they would rather cut through the bullshit and explore how something works themselves rather than be told how something works by a non-technical person. Developers also love to tinker and discover. That feeling of discovery though is a strong emotion. Think of the last time you discovered some new life hack or website that became your favorite and told your friends. That’s what inbound marketing leverages.

Effectively inbound marketing makes it appear that the developer discovered a new tool or platform on their own when in fact they were marketed to.

How to do inbound marketing with paid advertising

When done right, paid ads can drive adoption with low acquisition cost, but it requires much more planning and support than simply dumping a bucket of money on Facebook ads. If done incorrectly, you’ll still be pushing your product. The key is to be natural.

First you should decide on the goals of these initiatives, such as:

  • Brand exposure and driving traffic
  • Creating new leads and developer signups
  • Pushing existing leads to integrate your APIs
  • Converting developers to pay or have a larger deployment

Once you have your core objectives, you can lay out a content strategy to be used for social ads just like you would create a SEO strategy and keyword planner. Content is the number one item that makes your ads appear inbound. Content should be genuine and interesting to developers, but still relatable to the specific pain your tool solves.

It’s a fine line how specific you want to be. If you go too broad, then you’re not really pulling in the right developers that would adopt your solution. You can’t push out content that tells a developer to sign up when they don’t yet recognize they even have a problem. The way to solve for this is mapping the above goals to content that targets various stages of buying funnel:

Awareness/Exposure

Creating qualified leads

  • Thought leadership content/make yourself the domain expert
  • Why buy into the thesis/idea/product you’re solving. Still not about your company, rather just the problem/solution

Considering your product

  • Results and benchmarks from using your solution, technical whitepapers
  • Case studies and Comparison charts

#developer marketing #api best practices #developer relations #api adoption #developer advocacy #developer advocate #api product #api evangelist #api program #developer journey