1 Comment

PaaS, BaaS, Microservices, APIs – Lessons learned in the past and how to apply them now

By: Rahul Srivastava

“History Repeats Itself” is not the catchiest heading for a blog. These are heady times in our industry and its much more exciting to talk about The Next Big Thing than revisiting the past.

So my goal with this post is simple – as we move forward and build the next generation of Cloud Native Apps, let’s review some of the hard lessons we’ve learned over the last decade building and running large-scale n-tier apps, so that we don’t have to re-learn them all over again!

Business Agility, Customer Experience and Moore’s Law are driving and enabling the development of the next generation of “SMAC” (“Social Mobile Analytics Cloud”) applications.  That in turn has led to the emergence of interesting design patterns such as APIs & Microservices atop new platforms such as PaaS, IPaaS and BaaS. These platforms are typically being leveraged via pre-integrated offerings on public clouds such as VMware vCloud® Air™.

However, upon closer examination, one finds that these new design patterns and platforms are really an evolution of what we’ve done before. To take one example – folks often contrast/debate Microservices versus SOA, but the first incarnation of Microservices I ever saw were TUXEDO Business Services, except the lingua franca was FML/ATMI/<C|C++|COBOL> instead of JSON/REST/<your favorite language>.

Rather than debate whether it’s an evolution or revolution, I want to focus on the good news: we are able to have the benefit of foresight here. We can apply all the hard lessons we’ve already learned, rather than having to learn them all over again!

So what did we learn through our past journeys? We learned that there are some key challenges when building large-scale n-tier apps that become apparent only after your app has gone into Production and is a success.

You built it, they came and now you are having your “Oh S**t” moment!

So here’s my personal short-list of challenges that I advise my audiences to keep in mind as they are building their apps. Please note I am not including “Motherhood and Apple Pie” stuff like Security and HA, those are already a given.

  1. Design Time Governance
    • Service Lifecycle – how will you handle client apps as you upgrade your service or retire older versions?
    • Service Reuse – how will you figure out there’s an existing service you can reuse, rather than build your own? And how do you trust that service (as obviously the coder who wrote that service is nowhere as smart as you J)?
    • Data Models – how and where are you maintaining your standardized data models? How many versions of “Customer” are being defined?
    • Integration Patterns – there are different integration patterns that a service needs to support, depending upon the use case – transaction-level versus bulk-data, sync vs async, real-time vs point-in-time, etc. Do you know which ones are needed and which ones your service support?
  1. Runtime Governance
    • Client Segmentation – how are you providing different Quality of Service options to your “Platinum” customer versus “Gold” or “Silver” ones? What happens if Silver customer invocations flood your service, starving your Platinum customers? How will you determine how many clients of each type (Platinum/Gold/Silver) invoked your service and whether you meet their (differing) SLAs?
    • Transaction Tracing – if a client transaction failed, where did the exception occur in the Microservice/API call chain? Do you have any mechanism to react proactively to the exception, rather than react after the fact?
  1. Performance and Reliability
    • Your application is now only as reliable as the least reliable Microservice/API you are invoking. What contingency have you built for that?
    • Your application is now only as performant as the least performant Microservice/API you are invoking. Maybe you want to build contingencies (like Caching) into your application?

Hopefully I’ve planted some useful seeds in your mind as you build your next Cloud Native App, or any app for that matter.

In subsequent posts, we’ll examine how some of the leading PaaS and BaaS platforms such as Pivotal CF and Kinvey are addressing these challenges. We will explore the capabilities that public clouds such as VMware vCloud Air offer around Hybridity, Multi-Tenancy, Networking, Security, etc. to make these Cloud Native Apps truly enterprise grade.

I would love to hear your thoughts on the above. What items do you have on your shortlist?

For more information about vCloud Air OnDemand, visit, and keep an eye on the blog for upcoming tips and best practices for using vCloud Air.

For future updates, follow us on Twitter and Facebook at @vCloud and

Rahul is a Staff System Engineer with VMware, focused on Cloud Native Apps. He has lived in the Middleware & High Performance Computing world for the last 20 years – everything from Java, Integration, SOA, BPM to CEP, Data Grids, Real-Time JVMs. His favorite project remains building the Database access (JDBC) component of Oracle WebLogic Server. 

If anyone reading this blog has ever struggled with stack traces with the package “weblogic.common.resourcepool” in the middle of it, and wondered who was the joker who wrote that code, Rahul offers his sincere apologies.