Have a question? Want to report an issue? Contact JFrog support

Skip to end of metadata
Go to start of metadata

Getting Started

Know this

Consider this



This is my first content

Moving On

This is more important


Moving Sideways


Don't do this at home

“[In the future], the Internet will disappear… you won’t even sense it, it will be part of your presence all the time.” – Eric Schmidt, Executive Chairman, Alphabet, Inc.

The Promotion Pyramid: Building Better Software, Faster

It’s a given that computing, software, and IoT are all moving rapidly towards a state in which end-users perceive this aspect of their lives as they do public utilities. Thus, a reliable, secure, outside source provides an essential human need, such as electricity or water. The service is supplied where and when necessary, and in the quantities required, after which, at regular intervals, the consumer is invoiced and a payment returned for the utility of the rendered service. Otherwise, “Pay no attention to the man behind the curtain.” In a liquid software world, package-driven application and microservice development must achieve an equal level of seamlessness.

Consider that today, on average, any particular microservice is comprised of 50-100 packages. Each package will have its own life cycle and ability to be discretely released. Simultaneously, for any given package, all software/microservices using that package need to know when a stable, ready-for-prime-time version is available for immediate integration without having to be involved in or even exposed to the process that readied it for release. It’s simply building another layer of liquidity into the modern world. It’s making this aspect of DevOps seamless because quality and security at this level need to become just another cool, refreshing drink of water from the tap, another light switch being flicked on – something taken for granted.

Achieving this goal requires the integration of a promotion pyramid mechanism that’s constructed upon a rock-solid foundation for each package. Accordingly, every package should build, test, and verify itself within its own universe of package dependencies. It’s the establishment of a continuous build ecosystem at the lowest possible level with specific feedback always flowing to developers.

Base Level

All the packages comprising any particular microservice should always undergo full integration testing within the context of its own dependent services (databases, load balancing, etc.). At this stage, the critical objective is the resolution of all dependencies of all packages that are a part of any given service by automating the validation of all versions of all the various packages such that they lead to the construction of a stable, reliable microservice. Thereafter, it’s necessary to flag, tag, and promote all packages to all microservice DevOps teams, as well as any others that may want or need to be involved at further levels of integration.

Rising Up the Pyramid

Next, all microservices must be put together to verify they’re all performing as they should. This quality assurance testing (for sanity, function, stress, performance, etc.) allows for picking and choosing from different versions of the several microservices in play to be certain the desired operational goal is being executed without hitch or glitch.

Success at this level proceeds to the establishment and promotion of all versions of each of the many clients, servers, and services available to a wider world, i.e., to the developer, to QA and pre-production personnel, and beta testing consumers.

Scaling the Summit (Because It’s There…If We Build IT)

The liquid software objective is to dramatically minimize, if not entirely remove the opportunities for bad combinations to escape detection, scrutiny, and ultimate elimination. Any given set must function seamlessly with all involved in the process having the confidence that this is, in fact, the best, most up-to-date set possible. The tension will always lie in the zone between the latest, up-to-date version and the latest, up-to-date version that not only runs the testing gauntlet but, of course and most decisively, satisfies the end-user.

Removing all the (prior) versions and retaining a very limited set of packages, microservices, and applications gets us to the summit of the pyramid. This can be accomplished on a controlled, efficient, and continuous basis only in a liquid software environment. The need, at every stage and within each domain, for VCS and Git repository backtracking is a protracted, cumbersome, and often clumsy process. It’s fertile ground for mistakes to be made, flaws to go undetected, and for consumers to be needlessly frustrated when that which should function, doesn’t.

The key to exponentially streamlining all of these processes is binary package-level automation, where robots select from a huge number of components and then place, test, and validate infinite configurations without their needing to return to a build/source code point of origin. This allows for reliable improvements and innovations to reach the market at an accelerated pace. And that strengthens consumer confidence and trust, which assures business continuity and growth.


  • No labels