Skip to Content

One of SAP Web IDE’s main features is deploying applications to SAP HANA Cloud Platform (HCP).

In this blog I will showcase this feature and how it should be used in SAP Web IDE.



Software Deployment: The process of getting software to the point where it is available for active use.

Git: Widely used version control system for software development.


In the past, due to technical difficulties, the deployment to HCP was done by creating a Git repository and pushing the application’s files into it.

This created an unnecessary dependency between the deployment and the Git source control mechanisms.

After we solved the technical difficulties, the deployment was implemented using a dedicated API without the need to use Git actions. This allowed us to make the desired separation between the deployment and the source control.



The deployment to HCP feature is now
completely separated from the Git source control.

You have two options (depicted as radio buttons):

  • Deploy a new application
  • Update an existing application


When choosing to deploy a new application, the account, project name, app name, and version are displayed. You can select a different account (if you’re a member in one) or edit the app name and version.




When choosing to update an existing application, the account, project name and version are displayed and you need to select the application you want to update from the dropdown list. Based on previous deployments of this app we prefill the account and app name but it’s subject to change.




The list contains all the HTML5 applications in your account.




After deploying your application, it is ready to be used in your account!



Deployment Results


The deployment process creates the app in your HCP account under the HTML5 Applications section with the version you selected.

If your application has the SAPUI5 Client Build project type, an application build is performed in the background of the deployment process.
The build artifacts are then deployed to HCP and represent the productive  and more efficient version of the application. It does not reflect the project’s source files. The application is then ready for testing or productive use.

For more information, see Application Build.


Wait, where did my HCP Git go?


When you deploy the application to HCP, the source code is no longer automatically pushed to the HCP Git. Also, it is no longer possible to connect your project to the HCP Git repository via the deployment dialog.

The application’s source code should be managed and collaborated with other developers using the great tools of Git – merging, conflict resolution, versioning and more.


One proposal for starting to work with HCP Git:

  1. Create a project in Web IDE
  2. Create an HCP Git repository for your project from the cockpit, see Git Repositories:

  3. View the created repository details (you can also clone it to Web IDE) and locate the repository URL. For more information, see Creating a Repository.
  4. Initialize your local Git repository and connect it to the remote Git repository using the URL you obtained from the cockpit.
    See more details in this helpful video: Git Basics in SAP Web IDE


  5. Use the Git operations to fetch, commit, and push your changes. For more information, see Using Source Control (Git).



Suggested Work Model


After creating the application in SAP Web IDE, you can initialize a local Git repository for it and connect it to a remote Git repository on HCP.

Now you can develop your app, collaborate with your peers, and share your code with the help of Git.

Once the development is done and the app is ready to be published, you can deploy it to HCP and make it available for others (e.g. for testing, release, etc).

You can also create a tile for it in your SAP Fiori launchpad on HCP. For more information, see Registering Applications to SAP Fiori Launchpad.


Important Information


  • If you want to deploy again an app that was previously deployed, the dialog will open with the Update an existing application radio button selected by default and the application selected in the dropdown list. You can change both options.
  • The Edit Online button in the application’s page on HCP clones the Git repository of the application into SAP Web IDE. If nothing was pushed into this repository, a folder with only a git.ignore file will be created in your workspace because the repository is empty.


  • If you would like to preview your app directly from HCP, make sure your application contains at least one executable HTML file (e.g. index.html), and that it is configured properly in the neo-app.json’s welcomeFile property. For more information, see Welcome File.


If your application does not contain an executable HTML file, the link to the application URL will not be available and the application will not run from HCP.


When previewing the app from FLP on HCP, an executable HTML file is not required.

To report this post you need to login first.


You must be Logged on to comment or reply to a post.

  1. Gregor Wolf

    Dear Michal,

    is there already a way to automate the deployment or HTML5 apps? For the SITreg: SAP Inside Track Registration app that is using a HANA XS native backend we’ve created currently 3 front-end apps:

    As you see the repositories are hosted on GitHub to allow others to contribute by using their HCP Trial accounts. Currently I’m the one responsible to deploy on the SAP Mentors HCP Production account. I do that manually by using SAP Web IDE, pull the latest code from GitHub for the specific application and then deploy to HCP. You can check out i.e. the SAP Inside Track Participants. As you can imagine this process is tedious and could also be error prone.

    I’ve already checked the Partners Operations Guide for HCP, the HCP Lifecycle API and the Change Management with CTS+. The Operations Guide describes only manual ways from dev to QA and production. I’ve tried the Lifecycle API but it returned only the Java Applications that where deployed on my account. So it seems that only CTS+ might be an option. Can you provide me any direction that I should investigate further?

    Best regards


    1. Michal Keidar Post author

      Hi Gregor,

      Thank you for this very informative question.

      I’m not familiar with an automatic way to perform the deployment.

      Adding some colleagues who might have more details-

      Ran Hassid, Boris Tsirulnik – can you address Gregor’s questions?


    2. Jan Penninkhof

      I would expect the neo console client to take care of this, but it unfortunately doesn’t support html5 applications yet. We’re using neo to get Jenkinds to push new builds of the Lemonaid app to HCP though, but that app is built in Java.

    3. Robin van het Hof

      If I trace the requests being made from th HCP cockpit when uploading an HTML5 application, I see the following 3 requests:


      with payload:



      with multipart/form-data:


      Content-Disposition: form-data; name=”Html5FileImporter”; filename=”<name_of_your_app_as_zip>.zip”

      Content-Type: application/zip


      Content-Disposition: form-data; name=”_charset_”



      Content-Disposition: form-data; name=”Html5FileImporter-data”



      which returns your app-specific properties (repo, version, state, URL, etc)

      Maybe you can write your own logic based on Neo SDK to first log in, and then execute at least the first 2 requests

      1. Sascha Scholz

        Hi Gegor et al.,

        there are no REST API or console tool commands for HTML5 applications yet. It’s planned but I cannot make any promises or provide a timeline.

        So, currently, the only option is to reverse-engineer the Cockpit calls (beware of csrf protection). But it probably doesn’t come as suprise that this is not an officially supported solution and it could break at any time.


        1. Ivan Mirisola

          Hi Sascha,

          Is this situation still the same for Continuous Integration of HTML5 applications? Partners are asking me how to do CI with Travis or Jenkins without the need to encapsulate the HTML5 on a Java Application (as this takes 1 compute unit per application).

          I thought that the simplest solution would be to have the files pushed/commited to Account’s Git Repository created via WebIDE. Then a simple REST API would “activate” a version based on a branch corresponding to the application version or something else that needs to be executed internally (which in my opinion should already exist in place internally, since this is done by WebIDE anyway).

          I’ve seen the integration via an MTA archive, but doesn’t this imply the use NodeJS in a Cloud Foundry instante?


    4. Ivan Mirisola

      Hi Gregor,

      I was not aware of the fact that MTAR archives cloud be used to deploy HTML5 applications on SAP-CP Neo Accounts. Thanks @sascha.scholz for pointing that out to me.

      So basically you could use the procedures described below to perform CI for HTML5 apps:

      The how-to illustrates how to use Jenkins and NodeJS with Grunt Cli to automate the HTML5 packaging into an MTAR file. Then use the Neo Cli ( that comes with the SDK to push/deploy it to a Neo account.

      I haven’t tested it yet, but it should work.

      Check the following link as well:



Leave a Reply