My product has following structure: Website, iOS, Android mobile apps, backend.

There's a common code that is used by all components above. Say, you have to change a piece of code inside of it (just once in one place) to have changes appear in all components.

At the same time if say, there's a bug on website that requires change in this common code, we have to test mobile apps as well to make sure nothing broke there.

Now we are doing releases not too often, and we have all components released at once. This looks like an ineffective way to do releases. I'd like to release each product separately in own pace without compromising quality.

Any ideas how this can be done?

3 Answers 3


As a decision of this problem can be the following steps:


  1. Move the common code under some version control repo (git for example).
  2. In the code of every projects (Android, iOS etc) add the link to the common code repo.
  3. Get the last current version of the common code from repo for every projects.

Daily work

  1. Let's imagine that we want to update the Android app by improving the common code and we do it.
  2. Than we go to the Android App code and get the last current common code from the repo.
  3. Do the necessary tests of the Android App in accordance with the current development flow of your team.
  4. Make release of the Android App with the new common code.

Other work

  1. Do the Daily work steps for another projects in your list.

Thus you can use such method for improving only one project without fear of breaking your other projects.

enter image description here


One of the golden rules of continuous delivery is:

If something is hard, do it frequently

At the moment you are concerned that releasing to the various platforms will impact on quality. If you can alleviate that fear then the problem goes away.

I would be looking to:

  • Use extensive automated regression testing
  • Integrate and test frequently (perhaps even several times a day)
  • Use approaches like feature toggles and canary releases to de-risk releases
  • Automate your release process

This approach does require substantial investment of time and resources, but the benefit is much more flexibility in releasing and the ability to adapt quickly to changes.


This sounds like a primarily code-oriented problem. You want components of your application to be loosely coupled or completely decoupled. Using good programming principles like single responsibility and dependency-inversion, changing something in one system is not necessarily immediately impactful to everything else. From here, whether your common code is a library or some sort of service, you can use a versioning scheme to allow updates that impact one platform but not another.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.