How to Use Assembla with DeployHQ: Complete Integration Guide

Posted on

Devops & Infrastructure, Git, and Tutorials

How to Use Assembla with DeployHQ: Complete Integration Guide

Introduction

Assembla and DeployHQ form a powerful combination for teams that need enterprise-grade repository hosting with streamlined deployment automation. While GitHub and GitLab dominate the market with their community-focused platforms, Assembla offers a specialized alternative for teams with specific needs around compliance, multi-VCS support, and integrated project management.

This guide will walk you through integrating Assembla with DeployHQ, explain why Assembla might be the right choice for your team, and show you how to leverage both tools for efficient code deployment.

Why Choose Assembla Over GitHub/GitLab/Bitbucket?

Assembla's Main Advantages

1. True Multi-VCS Support Assembla is the only cloud-based platform offering managed hosting for all three major version control systems:

  • Git - Industry standard for modern development
  • SVN (Subversion) - Still widely used in enterprise and game development
  • Perforce - Essential for large binary files and game studios

GitHub, GitLab, and Bitbucket only support Git (Bitbucket dropped Mercurial support in 2020). If your team works with legacy SVN repositories or needs Perforce for game assets, Assembla is one of the few viable cloud options.

2. Compliance-First Architecture Assembla is built for regulated industries with enterprise-grade security:

  • HIPAA compliant - Healthcare applications
  • SOC 2 certified - Enterprise security standards
  • PCI DSS ready - Payment processing applications
  • GDPR compliant - European data privacy

The platform has maintained zero security breaches over 18 years of operation. For teams in healthcare, finance, or government sectors, this compliance focus can save months of security audits.

3. Integrated Project Management Unlike GitHub/GitLab which bolt on project management as an afterthought, Assembla was designed from the ground up to unify code and project management:

  • Native ticket system linked directly to commits
  • Built-in time tracking
  • Kanban/Scrum boards
  • Wiki and documentation
  • Client and contractor collaboration tools

You don't need separate tools like Jira - everything lives in one platform.

4. Enterprise DevOps Support Assembla provides managed cloud hosting with dedicated DevOps engineers, which means:

  • No infrastructure management required
  • Guaranteed uptime SLAs
  • Professional support for repository migrations
  • Optimized performance for large repositories

When Assembla Makes Sense

Choose Assembla if you:

  • Need SVN or Perforce alongside Git
  • Work in regulated industries (healthcare, finance, government)
  • Want project management integrated with your repositories
  • Require dedicated DevOps support
  • Have large binary files or game development assets
  • Need granular RBAC (role-based access control)

When to Choose Competitors Instead

Stick with GitHub/GitLab/Bitbucket if:

  • You need the largest open-source community (GitHub: 100M+ developers)
  • You want the most extensive third-party integrations
  • You're working on open-source projects (GitHub is the standard)
  • You're already deeply integrated into the Atlassian ecosystem (use Bitbucket)
  • You need the most comprehensive DevSecOps toolchain (GitLab)
  • Budget is very tight (GitHub's free tier is generous)

Bottom Line: Assembla isn't trying to compete with GitHub on community size. It's a specialized platform for teams that need multi-VCS support, compliance capabilities, or don't want to cobble together separate tools for code hosting and project management.

Setting Up Your Assembla Repository

Step 1: Create Your Assembla Space

  1. Sign up at assembla.com (starting at $19/month)
  2. Create a new "Space" (Assembla's term for a project)
  3. Choose your version control system:
    • Git - For modern web development
    • SVN - For legacy projects or teams requiring centralized VCS
    • Perforce - For game development or large binary assets

Step 2: Configure Your Repository

For Git repositories:

# Clone your Assembla repository
git clone git@git.assembla.com:your-space.git

# Add Assembla as a remote to existing project
git remote add assembla git@git.assembla.com:your-space.git

For SVN repositories:

# Checkout your Assembla repository
svn checkout https://subversion.assembla.com/svn/your-space/

Step 3: Add Team Members and Set Permissions

Assembla provides granular permissions:

  • Owner - Full access to all tools and settings
  • Write - Can commit code and edit tickets
  • Read - View-only access
  • Custom - Tool-by-tool permissions (Git access but not wiki, etc.)

This is more flexible than GitHub's simpler permission model.

Connecting DeployHQ to Assembla

DeployHQ doesn't have a native "one-click" Assembla integration like it does for GitHub/GitLab/Bitbucket. However, you can easily connect using the manual repository option.

Step 1: Get Your Assembla Repository URL

For Git repositories:

  1. In Assembla, navigate to your Space → Git tab
  2. Copy the SSH URL: git@git.assembla.com:your-space.git

For SVN repositories:

  1. Navigate to your Space → Subversion tab
  2. Copy the HTTPS URL: https://subversion.assembla.com/svn/your-space/
  3. Note your username and password (SVN uses HTTP authentication)

Step 2: Create a Project in DeployHQ

  1. Log into DeployHQ
  2. Click "New Project"
  3. Enter your project name (e.g., "Production Website")
  4. Select "Manually enter repository details"

Step 3: Configure Repository Connection

For Git repositories:

  1. SCM Type: Git

  2. Repository URL: Paste your Assembla Git URL git@git.assembla.com:your-space.git

  3. Default Branch: master or main

  4. Port: Leave blank (uses default SSH port 22)

  5. Click Save - DeployHQ will generate an SSH key

Step 4: Add DeployHQ's SSH Key to Assembla

For Git:

  1. In DeployHQ, copy the public SSH key shown after saving
  2. In Assembla, go to your Space → Settings → SSH Keys
  3. Click "Add SSH Key"
  4. Paste the DeployHQ public key
  5. Give it a descriptive name: "DeployHQ Production"
  6. Save

For SVN:

  1. In DeployHQ, enter your Assembla username and password
  2. No SSH key needed - SVN uses HTTP authentication

Step 5: Test the Connection

  1. Back in DeployHQ, click "Test Connection" or try to load branches
  2. If successful, you'll see your branches listed
  3. If it fails, double-check:
    • SSH key was added correctly to Assembla
    • Repository URL is correct
    • You have read access to the repository

Setting Up Your First Deployment

Step 1: Add a Server

  1. In your DeployHQ project, click "Servers & Groups"
  2. Click "Add Server"
  3. Enter server details: 
-   **Name:** "Production Server"
-   **Protocol:** SSH/SFTP (recommended) or FTP
-   **Hostname:** Your server IP or domain
-   **Port:** 22 (for SSH)
-   **Username:** Your server username
-   **Path:** `/var/www/html` (or your web root)
  1. Authentication:
    • Password - Enter your server password, or
    • SSH Key - Upload your private key for key-based auth

Step 2: Configure Deployment Settings

  1. Deployment Mode: 
-   **Standard** - Uploads only changed files (recommended)
-   **Full** - Uploads all files every time
  1. Config Files: 
-   Add files that should be different on the server (e.g., `.env` files)
-   These won't be overwritten during deployments

  1. Build Commands: If you need to compile assets:

    # For Ruby/Rails
bundle install
rails assets:precompile

# For Node.js
npm install
npm run build

# For PHP/Composer
composer install --no-dev

Step 3: Deploy!

  1. Click "Deploy" button
  2. Select the branch or specific commit to deploy
  3. Optionally add a deployment note
  4. Click "Deploy Now"

DeployHQ will:

  • Pull latest code from Assembla
  • Run your build commands
  • Upload changed files to your server
  • Execute any post-deployment scripts
  • Send notifications (if configured)

Complete Workflow Example

Here's a real-world workflow for a Rails application:

1. Development in Assembla

# Developer creates a feature branch
git checkout -b feature/user-authentication

# Makes changes and commits
git add .
git commit -m "Add user authentication [#42]"
# Note: #42 references an Assembla ticket

# Pushes to Assembla
git push assembla feature/user-authentication

2. Code Review in Assembla

  • Developer opens a Merge Request in Assembla
  • Team reviews code with inline comments
  • Ticket #42 automatically updates with commit references
  • After approval, merge to main branch

3. Automatic Deployment via DeployHQ

Option A: Manual Deployment

  1. Log into DeployHQ
  2. Click "Deploy" on your project
  3. Select main branch
  4. Deploy to staging or production

Option B: Automatic Deployment

  1. Set up a webhook in Assembla (Settings → Webhooks)
  2. Point to DeployHQ's webhook URL
  3. Configure to trigger on push events to main branch
  4. Now every merge automatically deploys!

4. Build Pipeline Execution

DeployHQ runs your configured commands:

# Install dependencies
bundle install --deployment

# Compile assets
RAILS_ENV=production rails assets:precompile

# Run database migrations
RAILS_ENV=production rails db:migrate

# Restart application server
sudo systemctl restart puma

5. Post-Deployment

  • Team gets Slack notification (if configured)
  • Assembla ticket #42 updated with deployment timestamp
  • Error tracking (Sentry/Bugsnag) tagged with release version

Advanced Configuration

Zero-Downtime Deployments

For production environments, use DeployHQ's atomic deployment features:

  1. Symlink Releases: 
-   Enable "Release" deployment mode
-   DeployHQ creates timestamped release directories
-   Symlink points to the latest release
-   Instant rollback by changing symlink

  1. Configuration:

    /var/www/
  current → releases/20250127-143022/
  releases/
    20250127-143022/
    20250127-121000/
    20250126-095500/
  shared/
    .env
    storage/
    uploads/

Deployment Groups

Deploy to multiple servers simultaneously:

  1. Create a Server Group in DeployHQ
  2. Add staging + production servers
  3. Use "parallel deployments" to deploy to all at once
  4. Or "serial deployments" for zero-downtime rolling deploys

Build Caching

Speed up deployments by caching dependencies:

# Cache Composer dependencies
if [ ! -d "vendor" ]; then
  composer install --no-dev --optimize-autoloader
fi

# Cache npm packages
npm ci --cache .npm --prefer-offline

Environment-Specific Configurations

Config Files feature:

  1. In DeployHQ, go to your server settings
  2. Add Config Files:
    • .env.production (on server) ← won't be overwritten
    • .env (in repo) ← will be ignored
  3. Manage sensitive credentials server-side

Frequently Asked Questions

Does DeployHQ have native Assembla integration?

No, DeployHQ doesn't have a native "one-click" integration for Assembla like it does for GitHub, GitLab, and Bitbucket. However, you can easily connect Assembla repositories using the "manual repository" option in DeployHQ. The setup takes about 10-15 minutes and works seamlessly once configured.

Can I use DeployHQ with Assembla's SVN repositories?

Yes! DeployHQ supports Git, SVN (Subversion), and Mercurial repositories. For SVN repositories hosted on Assembla, you'll use HTTP(S) authentication with your Assembla username and password. This makes Assembla + DeployHQ a great option for teams maintaining legacy SVN codebases.

How do automatic deployments work with Assembla?

You can set up automatic deployments using Assembla webhooks:

  1. In Assembla, go to Settings → Webhooks
  2. Add DeployHQ's webhook URL (found in your DeployHQ project settings)
  3. Configure it to trigger on push events to specific branches
  4. When code is merged to that branch, DeployHQ automatically deploys

This works the same way as with GitHub or GitLab.

Can I deploy to multiple environments (staging, production)?

Absolutely. In DeployHQ, you can:

  • Create multiple servers (staging, production, etc.) within one project
  • Deploy different branches to different servers (e.g., develop → staging, main → production)
  • Use Server Groups to deploy to multiple servers simultaneously
  • Set up different build commands per environment

What happens if a deployment fails?

DeployHQ provides robust error handling:

  • Deployment stops immediately if any build command fails
  • Full error logs are available in the deployment history
  • Files are not transferred if the build fails
  • You can roll back to any previous successful deployment with one click
  • Optional Slack/email notifications alert your team of failures

Can I integrate Assembla tickets with deployments?

Yes! Reference Assembla tickets in your commit messages using [#ticket_number] or #ticket_number:

git commit -m "Fix authentication bug [#123]"

Assembla will automatically:

  • Link the commit to ticket #123
  • Show commit details in the ticket
  • Update the ticket activity feed
  • Display deployment history

Is it secure to give DeployHQ access to my Assembla repository?

Yes, when done properly:

  • DeployHQ uses read-only SSH keys for Git repositories
  • Keys are specific to each project and can be revoked anytime
  • For SVN, use a dedicated deployment user with limited permissions
  • All connections use encrypted protocols (SSH/HTTPS)
  • DeployHQ follows security best practices
  • Enable 2FA on both platforms for additional security

Can I test deployments before going to production?

Definitely. Best practices include:

  1. Create a staging server that mirrors production
  2. Deploy to staging first for testing
  3. Use manual approval before production deployments
  4. Run tests in your build pipeline before deploying
  5. Use atomic deployments with instant rollback capability

DeployHQ's "release" mode creates timestamped deployment directories, letting you test and rollback instantly.

How much does it cost to use Assembla + DeployHQ?

DeployHQ:

  • Free plan: 1 project with unlimited deployments
  • Paid plans: Start at $10/month for 3 projects

Assembla:

  • Starter: $19/month (5 users, unlimited repos)
  • Higher tiers available for larger teams

Combined, it's cost-competitive with GitHub Team + separate project management tools, especially if you need multi-VCS support or compliance features.

Can I migrate from GitHub/GitLab to Assembla without downtime?

Yes. Here's the migration approach:

  1. Keep GitHub/GitLab active during migration
  2. Create Assembla space and import repository
  3. Add Assembla as a second remote in DeployHQ
  4. Test deployments from Assembla to staging
  5. Switch production deployments to Assembla when ready
  6. Archive GitHub/GitLab repo after verification

DeployHQ makes this easy since you can have multiple projects or switch repository URLs without reconfiguring servers.

What if I need both Git and SVN repositories?

This is where Assembla excels. You can:

  • Host both Git and SVN repos in the same Assembla space
  • Connect both to DeployHQ (create separate projects per repo type)
  • Manage everything from one platform
  • Use Assembla's project management tools across both repos

No other major platform offers this multi-VCS flexibility.

Does DeployHQ support build tools for Ruby/PHP/Node.js?

Yes! DeployHQ has built-in support for:

  • Ruby: Bundler, Rails asset compilation, RVM/rbenv
  • PHP: Composer, Laravel, WordPress
  • Node.js: npm, Yarn, webpack, gulp, grunt
  • Python: pip, Django
  • Java: Maven, Gradle
  • .NET: MSBuild, NuGet

You can specify language versions and run custom build commands before deployment.

Can I deploy the same code to multiple servers?

Yes, using Server Groups:

  1. Create a server group (e.g., "Production Cluster")
  2. Add multiple servers to the group
  3. Choose deployment strategy:
    • Parallel: Deploy to all servers simultaneously (faster)
    • Serial: Deploy one at a time (zero-downtime rolling deployments)

This is perfect for load-balanced applications or microservices.

What happens to config files like .env during deployment?

DeployHQ has a Config Files feature:

  • Mark files that should remain on the server (.env, database.yml, etc.)
  • These files won't be overwritten during deployments
  • Manage sensitive credentials server-side, not in your repository
  • Different config files per server (staging vs. production)

This prevents accidentally overwriting production secrets.

Conclusion

Assembla and DeployHQ together provide a robust, enterprise-ready deployment pipeline for teams that need:

  • Multi-VCS support beyond Git
  • Compliance and security for regulated industries
  • Integrated project management without juggling multiple tools
  • Streamlined deployment automation to any server

While GitHub and GitLab dominate the market with massive communities and extensive integrations, Assembla fills a specific niche for teams with legacy systems, compliance requirements, or those who prefer a unified code + project management platform.

The manual integration between Assembla and DeployHQ takes only 10-15 minutes to set up, and once configured, provides the same seamless deployment experience as native integrations.

Next Steps

  1. Sign up for free trials: Both Assembla and DeployHQ offer trials
  2. Migrate one project first: Test the workflow before committing
  3. Set up automatic deployments: Reduce manual work with webhooks
  4. Configure notifications: Keep your team informed via Slack

Questions or issues? Both platforms have solid documentation and support teams to help with migration and setup.

A little bit about the author

Facundo | CTO | DeployHQ | Continuous Delivery & Software Engineering Leadership - As CTO at DeployHQ, Facundo leads the software engineering team, driving innovation in continuous delivery. Outside of work, he enjoys cycling and nature, accompanied by Bono 🐶.