Posts

[et_pb_section bb_built=”1″][et_pb_row][et_pb_column type=”4_4″][et_pb_text]

When you set out to build your next custom software project, be it a web app, mobile app or API, cost is and always should be a concern. Custom software projects are almost always accompanied by a substantial amount of development hours to bring them to life, the cost of which can be a hard pill for cash sensitive startups, entrepreneurs and organizations to swallow. So you’ll likely find yourselves faced with the question: do I hire local or outsource overseas?

Today, we’ll be discussing the details of overseas development and why a local software team can often save you in the long run.

Communication, Communication, Communication

In our experience, a project’s success often hinges on successful communication between the client and the development team.

Yes, practical details such as time zones and modes of communication are important (Can you pick up the phone and call the development team? What about a face-to-face meeting? Will your questions be answered in an acceptable amount of time?), but beyond the nuts-and-bolts, it’s important to place value on the ability for your development team to truly understand your project. Do they understand what you are asking to be built? Does the team understand your overall strategy for the app? Are they able to push back and offer alternative solutions or advice during technical challenges?

Building a custom app is rarely a cut-and-dry project and quality communication as your big idea is being brought to life can make all the difference.

Total Cost, not Hourly Rate

It almost goes without saying but is still important to mention here that when considering the dollars and cents of the development team you hire, think about what the total cost will be, not the hourly rate.

An hourly rate of $150+ for an experienced local developer may seem like a lot when compared to an overseas developer charging one-third of that (or even less), but take the time to consider the value that can be provided during that hour. An experienced local developer may work more efficiently and avoid many more pitfalls than a potentially inexperienced overseas developer. In the end, you may find yourself coming out even or ahead by staying local.

Quality of Work

Building a web app or mobile app is no easy task. Besides the strategy of the app itself, you’re also juggling marketing, revenue models, operations and more. The last thing you want to worry about is the quality of the work you’re paying for.

At Oak City Labs we know the value of quality assurance, continuous integration and automation, which shows in our final product. Whether you’re working with a team based locally or overseas, it’s incredibly important that you feel confident in the quality of the work being produced. When your app has its public launch in the app store and you see hundreds and thousands of downloads that first day, you won’t want to find out at that time that the quality is far less than you expected.

As you are evaluating the quality of any software team (local or offshore), consider the following questions:

  • How often is the software team going to provide beta releases so you can review and test? How soon during the development phase will you see these?
  • Who on the development team will you be talking to during the project? Will you be able to speak with the developer working on your project? Does the team provide regular status updates or weekly reports reviewing progress?
  • Will you have access to the code base (even if you aren’t technical) should your relationship go awry?
  • What is the software team’s experience with the release process? Have they successfully released projects to the App Store, Google Play Store, etc.? Do they have a tried and true method they follow for QA, bug fixes and releases?
  • What is their philosophy on building products from scratch vs. using existing third party libraries?

If you’re looking to get started on developing your custom app idea and need help navigating the pros and cons of working with a software team locally vs. overseas, we’d love nothing more than to chat with you further!

[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]

If you’ve ever found yourself seriously thinking about building a mobile app, but have no idea where to even begin, this post is for you! In a world where it seems like everyone has an app idea, the truth of the matter is that there is plenty of room for innovation and new ideas in the marketplace. But to take your idea and make it a reality, you’ll need to keep the following in mind.

First: Market Research

At Oak City Labs, we’re passionate about market research and strongly believe that it is the key to your success. Before writing the first line of code, it’s important to make sure that your idea is fully thought through. And while market research is definitely the most strategic route to take when your app is still just an idea, it’s also the route that can end up saving you money in the long run.

To take that first step in getting your app idea off the ground, begin by doing some free research. That’s right: FREE! Using everyone’s trusty friend Google, you can find information showing you what your app idea’s total addressable market (TAM) could be. Along the way, you’ll find competitors and possible features. You’ll also start to refine what your app idea is and what makes it unique. We also encourage those in this stage of the process to talk to people and conduct Voice of the Customer surveys and, ultimately, create a value proposition statement. The goal with all of these steps? To help you refine your app idea, discover what makes your idea unique and set you up for success as you begin the process of building the app.

Next: Partner

After doing your fair share of research and being confident in your decision to move forward with building your app, it’s time to find a partner that can help bring your idea to life. When looking for a development company, we encourage you to prioritize the following:

  1. Reputation: How experienced is the development team? How many apps or custom software projects have they led or developed before? What do their clients have to say about them?
  2. Relationship: How are they planning to communicate with you throughout the project? Will there be weekly check-in calls? Will they help you flesh out your idea strategically, advise of feature prioritization, consult with you on growth strategies and more?
  3. Results: Are they going to be able to solve your problem? Is this partner able to help you achieve the results you’re looking for?

We created Oak City Labs to answer a lot of these questions – to give you the missing pieces to transform your app idea into a real, quality product that makes a difference. Our team has spent decades in diverse roles across multiple leading tech companies. From this experience, we understand how to deliver on all facets of the app creation process – from the technical considerations, to project management, to product-market-fit, and all the important questions you might not think to ask. We’ve learned these lessons so you don’t have to.

We know how all of the pieces of development fit together so we bring a fully informed approach to your final product. By building strong client relationships – guiding you through every step, valuing your feedback, and collaborating on the process with you – we craft the well-designed, marketable app that you want to build.

Then: Build

Assuming you’ve properly validated your app idea and selected the best strategic partner, it’s now time to begin building your app. The process involved can include everything from wireframing and user testing, to visual and interaction design depending on your specific needs.

At Oak City Labs we make sure to have a full feature list in place before beginning development. Then we prioritize the feature list to ensure that the most important things are built first. If budget or time becomes an issue, we always want to ensure that your high priority needs were taken care of in the beginning.

As development proceeds you should expect lots of testing through frequent beta builds provisioned by the development company to your device. And you should expect lots of testing on their end too.

Don’t Forget: Marketing

It would be easy to wrap up this post with the next step and call it a day. But the truth is that successful apps won’t take off and have a hope of succeeding if there isn’t a marketing plan in place. While your app is in development (and, quite honestly, long beyond that), you should be working on and executing your marketing plan. From a website to social media, and even press kits, your marketing plan can make or break your app’s chances for success.

Finally: Launch (& Rinse and Repeat)

It’s the finish line! Well, sort of. At the completion of the build and testing phase of the project, it will be time to launch your app and we’ve created a whole checklist to make this process successful here, here and here.

Once that first release hits the store, you should celebrate! What an accomplishment! But keep in mind that it’s really just the beginning. Following the launch, your app will need to be nurtured on an ongoing basis if you hope to grow your audience (and therefore your business!). You’ll need to address bugs, add new features, adapt to new technology challenges and much more.

As with any business idea, there’s a lot that goes into going from an idea to a bona fide product. At Oak City Labs, we love helping entrepreneurs make their ideas a reality. If you have an idea and think we’d be a good partner for you, we’d love to chat!

As a web and mobile app development shop, we love to talk about technology choices. Many people don’t really care what technology solution is used to solve a problem as long as the problem itself gets solved. And that’s OK in the “Wild West” days of a startup. However, as a business matures, sometimes the technology choice will hinder you during the growth phases. When a business reaches a certain scale, they will often end up rewriting the entire application. It’s not always avoidable but we like to try our best to manage the risk of a full rewrite later on.

At Oak City Labs, we approach technology choices with what we like to call a “sniff test.” It’s called a sniff test because it’s brief and not all encompassing. It’s also not meant to delve into great detail since we aim to make timely decisions looking at trends. This sniff test is very much business oriented, which really ought to be the driver behind most of your choices. It’s also why we don’t recommend cross-platform development and why we don’t throw the latest Javascript framework into production heavy work. That’s a whole other discussion which should be aided by beer, wine or your calming beverage of choice (Mt. Dew counts!).

Sniff Test Quiz

1. How long has the language or technology been around?
We’re not looking for the most mature, but we like to see longevity for projects and languages. This tends to influence answers for the rest of our quiz.

2. Is there widely available support, including forums or consultants?
This is very related to #1. Is a fix at 2:00 am in the morning just a Google or Stack Overflow search away?

3. For open source projects, how active is the community?
When was the last commit? How often are releases? How many contributors?

4. Is there support from scalable cloud services like AWS and Google Cloud?

5. Can we easily and readily hire a developer with little ramp up time?

6. Is the project or language trending up or down?
Not always a perfect measure but can be telling. Google Trends and Stack Overflow can help with this analysis. Again not perfect but it’s what we’ve got without in depth technical analysis. Here’s an example over the last five years between three prominent languages.

7. Was the project or technology bought or started by a large company?
This can be a good thing but we tend to shy away from backend service providers that might get shut down as Facebook did with Parse. Our preference is to build an app so the full stack is modular and not reliant on a single provider.

Ultimately we want to make choices that will provide long term growth and scalability for our clients. For example, while PHP may be a great choice for some niches it might be tough to hire in your local area for a PHP developer or it could even be on the decline in usage. And sometimes we’ll use a technology for a small part of an app but not for the whole application. For example, a database like MongoDB might be good for caching trivial data but we wouldn’t use it for mission critical features of an application.

We also like to choose technologies that fit business cases. Let’s say a company is in the life science market and will be performing data analysis. We would likely recommend Python because it’s somewhat mature and has all the science and math support needed for detailed analysis. It’s also widely used by the scientific and research community. If you’re in the Fintech space, you might choose Microsoft products because of the enterprise level support and prevalence of .NET developers already in finance.

The sniff test still remains the same when considering long term viability of the technology stack regardless of the market or software application. It doesn’t mean all of your choices, or ours, will be correct up front, but it does mean you can help manage the risk. If you’re thinking about an idea for a web or mobile app, contact us today and we can discuss performing a sniff test (and more!) for you.

We’re in the thick of testing on a large project right now. It’s a (delicious!) new release that we can’t wait to share more about later this summer. While it goes without saying that any release, big or small, should be thoroughly tested, you can often find yourselves in crunchtime near the end of a project. That crunchtime can lead to the choice between meeting a looming deadline and thorough quality assurance. Today we’re sharing all about testing and why it’s so important for your mobile app’s success.

Testing 101

When we talk about testing your mobile app, we aren’t just talking about making sure all the buttons work. Thorough testing goes well beyond that!

At Oak City Labs, we begin testing as early as possible in the development process. We’re an agile shop, so we place a lot of value on getting a (semi-)working version of the app in front of our clients for review as soon as possible while development is still in progress. As soon as we have a working, somewhat functional mobile app ready, testing begins.

Our testing process is just that: a process – a very detailed and thorough process. Armed with our trusty QA Checklist, we thoroughly test the mobile app inside and out. We try to break it in as many ways as possible (better now than when in production!). We work through each and every screen in the app comparing it with the designs, testing it against our use cases, proofreading copy and looking at scrolling and swiping behavior. We check how the app integrates with other apps, we test push notifications, observe screen orientation and more.

I said before that we test each mobile app inside and out. More than just a common phrase, we really do test inside our mobile apps. On the “inside,” we evaluate performance by testing battery usage, install/uninstall process, loading, network connection and the list goes on!

We also place priority on testing the app from the perspective of a first time user. As we near release, it’s all but certain that we’ve been using and testing the app for months. It’s important to take a step back and evaluate the app with fresh eyes to make the user experience for those who interact with it for the first time is optimal.

Why It Matters

You may be saying, “Wow, that seems a lot of work! Is it really worth it?” The answer is YES! Statistics tell us that about 25% of users use an app once and then never use it again. Add in crashes or a mediocre performance experience and you are sure to see that percentage rise.

Trying to break into a crowded market? There’s no easier way to differentiate yourself – in a bad way – than with an app riddled with bugs and performance issues. We’ve shared before about the importance of reviews for your mobile app and negative reviews left by customers frustrated by an untested app aren’t a great way to start.

Testing matters. At Oak City Labs we place high value on thorough and complete testing before a mobile app’s release. If you are looking to create a mobile app – one that is sure to be thoroughly tested – we’d love to hear from you!

NinePatch drawables in Android offer a way to create resizable bitmaps that only stretch the sections of the image that you specify. This is useful for creating backgrounds for TextViews, Buttons and any view whose size may vary depending on the content, as well as when creating splash screens that have a logo whose aspect ratio you don’t want to be distorted.

NinePatch drawables consist of the original image surrounded by a one pixel border of empty pixels by default. The top and left side one pixel border is used to specify (with black pixels) what vertical and horizontal slices of the image can be stretched to make the image to fit its container (instead of simply stretching the image and changing its aspect ratio). This way areas of the image with content you do not want to be stretched can remain at their original aspect ratio. The bottom and right side one pixel border is filled in with black pixels to specify the area of the image that any content that sits on top of the image should reside in (essentially, the padding for the view that this image will serve as the background for).

The following is an example of a NinePatch image:

The black sections of the top and left one pixel border are circled in red. The logo in the center will maintain its aspect ratio while the vertical slats designated by the top one pixel border will be stretched horizontally and the horizontal slats designated by the left one pixel border will be stretched vertically. When two or more stretchable slats are specified for a dimension as above they will maintain their size relative to each other when stretched (so the logo will stay centered).

It is important to note that if you don’t want to specify the content area (the padding) and would like content to fill the entire image, you should fill the right and bottom side 1 pixel border with black pixels as in the example above. If the content area is not specified (the bottom and right sides consist of only empty pixels), the content area will default to the area designated by the top and left side one pixel border.

Android Studio has a tool to generate and edit NinePatch drawables. To access it, right-click on your image file in the Android Studio file browser and find the “Create 9-patch file…” option. You’ll want to give the new 9-patch file a unique name so it doesn’t conflict with the existing image resource (or just delete the original). Now find the newly created NinePatch image (it will have “.9” prepended to the file extension, i.e. your_image.png becomes your_image.9.png) and open it. A full tutorial for the Android Studio NinePatch editor can be found here.

Welcome back to this series! Last week, we started walking through a checklist of necessary steps to take before launching your next iOS app and reviewed all the details about your Product Page listing. Today we’re discussing how to effectively market your iOS app.

Marketing Your App

Before you even launch your app and long after its first release, marketing should be a top priority. The more awareness you can bring to your idea, the more users you’ll see downloading your app. Consider the following as a part of your core marketing strategy.

  • Website: Your online presence can begin with a simple landing page. Start by claiming your app’s domain and setting up a basic website with a contact form, social media links and a short description. From there you can expand with more content as you have it. Use your website to collect leads from interested users that would make good beta testers or want to be notified when the app hits the market.
  • Social Media Channels: Twitter, Facebook, Instagram, Tumblr, LinkedIn…the list goes on. Think through the social media channels your target audience are using regularly and start building a presence there. Before launching your app, use social media to share updates, behind the scenes details and sneak peeks, as well as solicit feedback and ideas on features. As you near your launch date, you should use social media to build hype and excitement for the big release. And once the app launches, remember to continue monitoring your social media to drive downloads and respond to customer feedback.
  • Press Kit: Depending on your marketing strategy, a press kit may or may not be a necessity. If you plan to pitch your app to get press coverage leading into your launch, a press kit is a must-have. Your press kit should be a one stop shop for bloggers and journalists who you want to cover your app. Make sure to include visual assets like your app’s logo and icon (in all sizes, resolutions and file formats), as well as screenshots and a demo video if you have one. Content such as your app’s description and basic business information (launch date, price, platform, etc.) is also essential to include. Remember your goal is to make easy for someone to want to cover your app.

Join us again next week as we close our series talking all about app analytics – a crucial step for long term success! Update: the series continues here.

Following the success of our last workshop in April, we’re excited to present this workshop again – this time at The Frontier in RTP on July 11.

If you’re considering building a mobile app or are embarking on a custom software development project, we’d invite you to join us for a free workshop next month. We’ll be discussing the most important, yet often most overlooked, step as you begin your project: market validation. We’ll also talk through technology and why it matters.

You’ll have full access to the entire Oak City Labs team for this engaging and interactive presentation, as well as Q&A and networking following the workshop.

We hope to see you there!


July 11, 2017
The Frontier (The Classroom)

  • Registration & Continental Breakfast – 8:30 – 9:00 am
  • Workshop – 9:00 – 10:30 am
  • Q&A and Optional Networking – 10:30 – 11:00 am

These days it seems like everyone’s making an app. At Oak City Labs, we love talking with entrepreneurs about their next great idea!

If you’re considering building a mobile app or are embarking on a custom software development project, we’d like invite you to join us for a free workshop next month. We’ll be discussing the most important, yet often most overlooked, step as you begin your project: market validation. We’ll also talk through technology and why it matters.

You’ll have full access to the entire Oak City Labs team for this engaging and interactive presentation, as well as Q&A and networking following the workshop.

We hope to see you there!

  • When: Thursday, April 27
  • Where: Halle Cultural Arts Center – Studio Gallery, 237 North Salem Street, Apex, NC 27502
  • Schedule:
    • Registration & Continental Breakfast – 8:30 – 9:00 am
    • Workshop – 9:00 – 10:30 am
    • Q&A and Optional Networking – 10:30 – 11:00 am

Since joining the team at Oak City Labs last year, I have had many conversations with friends, family and prospective clients about mobile app development. When I show them an app we’ve built, like CurEat, they often tell me that it looks great, and then ask me to show them which parts of the app I made. While seemingly an innocuous comment intended to allow me to showcase my hard work and reap some easy praise, this particular request typically leads me to release one of my patented <heavy sighs>.

But Cory, why do you heavy sigh at such a polite, ego-boosting request, you ask? Well, fellow human, I release the air from my lungs at a much faster rate than usual in an exasperated manner because users of our apps don’t actually see anything I have made. They see the work of the design team in the visuals of the app. They see the buttons, lists, login screens and settings menus that Jay (iOS) and Taylor (Android) have coded in. They even see the legalese a lawyer somewhere put together. So when I tell people that I spent over a year working on an app after explaining that there is no visual evidence of my work at all, they get this sort of half-confused, half-amused look on their face.

Of course, I could simply tell people that I am a backend developer who helped make the Python Flask server, PostgreSQL database structure, RESTful API and Angular webapp that allow the mobile app to be more than a sad, functionless, empty shell. This jargon only helps those with a technical background, and usually leads most others to say something along the lines of “Oh, OK…” when in reality, they’re thinking “Was he even speaking English?”

And so, through a long, arduous process of trial, error, confused looks and copious amounts of feedback, I have concocted what I believe to be the ultimate formula in explaining what my actual role is in the app development process.

To aid in understanding my role as a behind-the-scenes magician, I will refer to the Snapchat app as an example.

For those who aren’t familiar with Snapchat, let’s run through a typical Snapchat use case. This is assuming you already have an account and are logged in.

Step 2: Snap a super artsy picture of your keyboard and wrist rest

Step 3: Send it to your friends (Some names below may or may not be based on the many nicknames of Burton Guster)

Aaand we’re done! I have now sent a poignant photo of my keyboard to two of my closest imaginary friends. Soon, they will receive a notification of the photo and will be able to open and view it for themselves.

This is the process for using the app, but to understand how we are able to get to this point and do such a thing, we need to step back to the very beginning.

Here is the terminology I will use in the following examples:

  • Mobile Developer – Somebody who builds the actual app that a user sees on their mobile device
  • Backend Developer – Someone (like myself) who works on the behind-the-scenes details such as the server, API and web framework. If this doesn’t make sense, that’s OK – we’ll get there!
  • Snap – A snap is an image that you exchange with friends on Snapchat

When the app loads, you have the option to log in or sign up. So far, this is all the work of the mobile developer. They created this screen, pulled in images from the designer, added some text onto buttons, and bam. This screen is born:

Now let’s say you click Log In. You are then taken to this screen:

This screen lets you log in with your account information and takes you into the part of the app where you can actually send and receive snaps. Every “usable” thing on this screen was added by a mobile developer: the input areas for username and password, the “Forgot your password?” link and the “Log In” button. So far, the backend developer hasn’t played a role in either of the previous screens.

Now, what happens when you press the “Log In” button? Does the phone magically know whether your account info is valid or not? If that information were only stored on your phone, how would you be able to log into Snapchat on a new phone with the same account?

The answer: You wouldn’t. Your account information is not even touched by the mobile developers!

*My Time to Shine!*

There are a lot of behind the scenes details happening here that the backend developer is responsible for, so let’s break down the differences between the work of the mobile and backend developers in the above scenario.

Technical Breakdown:

  • Mobile Developer:

    • Create app screen with inputs
    • Send username/password to server
    • Receive output from server telling the app if the login was successful
    • Continue on to the next app screen if the user logged in successfully
  • Backend Developer:

    • Tell server how to handle a request to log in a user
    • Tell server how to check with the database to confirm/deny a login request
    • Tell server how to send a request back to the app if the user logged in

Non-Technical Breakdown:

The mobile developer creates the code for the login screen, the backend developer creates the code for all of the actual “logging in” and checking of whether you are a valid user or not.

Let’s go back to the scenario of sending a snap to your friends.

Starting with my super duper artsy photo again, we can examine this screen. All the interactions on this screen are completely up to the mobile developer. A few examples are the ability to save this image or add text to it. Now, let’s say the user clicks the button in the bottom right to choose which of their friends to send the snap to.

We’re taken to this screen. The app displays a list of names which are all of the potential friends you could send your snap to. You select the ones you want, then click the send arrow in the bottom right to send your snap to these friends. Everything visible is presented with code from the mobile developer still. Except…

Let’s back it up.

Where did your friends list come from? Does your phone just magically know which of your friends have snapchat and also have you as a friend? How would you add or remove a friend? And what are those numbers and emojis next to the stars on the right side of each name row?

That’s a lot of questions, so let’s do a breakdown like we did before.

Technical Breakdown:

  • Mobile Developer:

    • Request list of friends and friend information from server
    • Display list of friends
    • Display information about each friend (such as the numbers and emojis)
    • Allow the user to select which friends will receive their snap
    • Tell the server who the user wanted to receive their snap
  • Backend Developer:

    • Build a list of friends and friend information for the given user and return the information to the app
    • Perform the actual sending of the snap to all of the selected friends.
    • Notify all the friends that they have a new snap

Non-Technical Breakdown:

The mobile developer creates the code that displays all the friends and let’s the user choose who to send the snap to, but the backend developer creates the code that tells the app who the user’s friends are and the code that actually sends the snap to those friends.

At the end of the day, there’s a lot of communication that needs to happen between mobile and backend developers, because as you can see, they depend on each other very much. Without a mobile developer, all the backend logic and data and snap sending would be pointless. Similarly, without a backend developer, Snapchat wouldn’t actually be able to do anything. It might sit there looking pretty but you wouldn’t be able to send your snaps to anybody, which would be quite sad.

I hope my examples helped, but if not, here are a few analogies to provide more clarity:

Non-Technical Analogies:

  • A mobile developer is like a news anchor. Without the backend developer (teleprompter), the news anchor would just sit there looking pretty without knowing what news to tell viewers about.
  • Alternatively, think of a mobile developer like a grocery store, choosing how to display all of the food that the backend developer delivers. Without the shelves and organization from the mobile developer, all of the food from the backend developer would be too chaotic and unstructured to give to the shoppers. But, without the backend developer, there would be no food at all to give to the shoppers.

Technical Analogies:

  • A mobile developer creates your Gmail app, but without the backend developer, your email would never show up in the app.
  • A mobile (or web, in this case) developer would create the Netflix app or website, but without the backend developer, no shows would show up or be watchable.

 

It’s a three letter acronym that’s thrown around all the time, yet most non-technical founders and businesses gloss over the impact of an API, the value it can add to your business, and how it can help you in the future. We’ll start by covering what an API is and how it works.

What is an API?

API stands for application programming interface, and most explanations on the web want to explain a whole bunch of other things like clients, servers, JSON, etc. We won’t go into that for this article because often times it’s kind of boring for folks that don’t work with it everyday.

You probably have a ton of apps on your phone, so for this scenario let’s use Google Maps. When you open Google Maps and search for “grocery”, the app needs to get that information from somewhere.

While most new phones have a ton of processing power, the amount of data behind something like Google Maps is huge. Since your phone can’t handle all of the data for every possible thing people search for, the data needs to live somewhere else. Additionally, when Google needs to change or update the search results, they don’t want to push constant updates to your phone. So it makes sense for all that data, and all the processing, to sit and take place somewhere else. Usually this is in the cloud, often a service like Amazon Web Services, Google Cloud, Microsoft Azure, etc.

OK, so we know your phone needs to contact the cloud for some information but how does it know which cloud, where in that cloud and what info to get? That’s all a part of the API! The API has a URL just like any other web page. Therefore, when you search for “grocery” in Google Maps, your phone hits that URL in a special way and automagically serves up specific information about grocery stores to your phone.

As one of my former economics professors used to say in class, “So What?” The phone talks to a server (aka the cloud) and the server returns some information that the phone not-so-magically understands, how does that really help?

What does that mean for you or your project?

It means that your project’s API (the thing that magically serves up content so the app on the phone can operate) needs to be super well documented, well laid out and secure. It also means that time and attention should be devoted to correctly building it out. The API is basically a map for the app on your phone. If you also have a web app that matches, it will use the same API. If the API is poorly documented, you can expect some real problems both during development and afterward – making troubleshooting or sharing information a nightmare.

What does this have to do with business?

A large number of companies sell the data behind an API to other parties. Google, again, is a prime example. As developers, we use the Google Maps API quite a bit.

As a business you may not be thinking about selling the data, but what if you have integration partners down the road? For example if you’re building a CRM, what if people want to sync data between their app and yours? Or if you have a product in the healthcare space, maybe you’ll need to integrate with Epic at some point. You’ll need to not only understand your API but understand their API in order to be successful.

Other examples include the Facebook Graph API and Twitter APIs.  Both are open to developers to use for new apps. ProgrammableWeb has an online directory of APIs that are both free and paid. It’s worth a little searching if you’re building an app to see if you can buy versus build from scratch.

The API market itself is continuing to grow, including tools and servers around APIs. Take a look at two major acquisitions by Oracle and Google for API design, documentation tools and management services.

If you’re building an app, definitely consider the market potential for the API. Often, there is more long term viability behind the data and what others can do with the data versus the actual app.