Back

One DocuSign API Integration for Lease Signing Across a Multi-Brand PropTech Platform

Duration: July 2024 – January 2026

Customer location: Ireland

Industry: Real estate

Services: Dedicated Team ● Backend Development
Codebase & Process Audit

Tech stack: Ruby on Rails ● DocuSign eSignature REST API
DocuSign Connect webhooks, background jobs

Dedicated team behind the project

The Ralabs team worked inside the client’s existing product team, alongside its Product Owner, Lead Engineer and frontend developer.

Nazarii

Senior Ruby on Rails Engineer

Yevheniia

Project Coordinator

In brief

Ralabs rebuilt the DocuSign API integration for Levry, an Irish PropTech platform, as a Ruby on Rails service layer. One integration now sends, signs and voids leases for both Levry’s enterprise white-label tier and the marketplace. By default, each contract goes out under the approving manager’s identity, and every fallback is logged.

The client

Levry is an Irish PropTech startup building an agentic AI operating system for commercial property leasing. Its commercial lease management software captures bookings, builds deals, handles payments and contracts, and tracks occupancy across an operator’s portfolio.

The platform now runs three brands on one multi-tenant codebase.

Client achievements:

3 deployment models on one codebase

A self-branded marketplace, an enterprise white-label tier, and an API integration.

Live with a shopping centre operator across Europe

eLeaseLoop started in Spain, launched in Italy, and is rolling out to France, Portugal, Poland, and Romania.

9,000+ bookings and ~€250K in monthly booking volume

Short-term retail space booked across the platform’s brands, based on 2025 internal figures.

The challenges

In mid-2024, the client signed a new enterprise white-label partner and needed to onboard it across several European markets. The small in-house team needed more backend capacity, and the electronic lease signing flow had to scale from one marketplace to an enterprise operator with complex sign-off rules.

Key challenges included:

A signing flow built for one marketplace

The earlier DocuSign integration was a single class built for the marketplace. It had no room for enterprise templates, multi-step approvals or per-market content.

Approval chains that vary by operator

Large operators need a regional manager, a finance lead and a director to sign off in sequence. The platform had to build that order per booking, not rely on one fixed template.

One signing flow for two very different products

The same codebase had to serve the enterprise tier and the self-branded marketplace, each with its own templates, roles, and content.

An audit trail that reflects real authority

Contracts sent from a generic service account would hide who actually approved each deal. The client needed every envelope (DocuSign’s term for a contract package sent for signature) to carry the approving manager’s identity.

Silent failures in an asynchronous process

E-signature runs on background jobs and webhooks (DocuSign Connect, the automatic notifications DocuSign sends back to the platform). Without explicit handling, a failed send or a cancelled booking could leave contracts in the wrong state unnoticed.

Why the client chose Ralabs

Levry needed backend capacity on its existing Ruby on Rails codebase within days, not after a hiring cycle.

Ruby on Rails depth from day one

The engineer could work in a mature production codebase without a long ramp-up.

Capacity that scales with the roadmap

The engagement started small and expanded as the enterprise rollout gained pace.

A team that fits the existing process

Ralabs engineers join the client’s workflow, tools and review rules, and the client keeps ownership of product and architecture.

Delivery oversight included

A project coordinator worked alongside the engineer on planning, reporting and communication.

What was done

Ralabs embedded a dedicated development team, a Ruby on Rails engineer and a project coordinator, into the client’s product team. The client owned product priorities, architecture decisions, and code review. Ralabs delivered backend features and led the DocuSign API integration, which replaced an earlier single-class implementation with a dedicated service layer.

Ran a codebase and process auditRalabs delivered recommendations on test coverage, service boundaries, background processing, documentation, and secret management.

Worked through the platform backlogBeyond DocuSign, the engineer worked through the client’s backlog of platform tickets across both brands.

Rebuilt contract signing as a DocuSign service layer in Ruby on RailsApplying its Ruby on Rails development practice, the team built a new integration that spans 36 files and about 2,570 lines. It adds two background workers, a webhook controller, admin panels, and about 1,260 lines of automated tests.

DocuSign integration features we built

Sending as the approving manager

Each contract is sent under the identity of the manager who approved the booking, using DocuSign JWT user impersonation (an OAuth flow that lets an app send envelopes as a specific user after that user grants consent). The DocuSign audit trail shows real signing authority. If that manager is unavailable, the system falls back in three tiers and logs each fallback as a named incident.

Consent management

Impersonation requires each manager’s consent. The platform generates personal consent links and shows live consent status per manager in an admin panel. A lapsed consent is caught before a lease fails to send.

Verified template access

The integration shares the required template with the sender, then checks with a separate request that access actually works. If it does not, the send continues under the admin account and raises an alert.

One orchestrator, two creation paths

An orchestrator handles routing: it sends each booking to a DocuSign composite-template path or a document-based path, depending on its configuration. Composite templates let one envelope combine several templates and documents. Both paths return the same result format, including whether a failure is safe to retry.

Reliable webhooks, retries and envelope voiding

Envelopes are created in a background queue with seven retries. A booking is marked approved only after DocuSign confirms the send, and DocuSign Connect webhooks keep each envelope’s status in sync. Cancelled bookings void their envelopes, including the edge case where a booking is cancelled before its envelope exists.

Signature pages and localisation

Signing order, required roles, booking financials and annex documents are assembled automatically. Missing signers block the send with a clear error. Notification emails go out in English, French, Spanish or Italian, based on the listing’s country.

How the collaboration worked

Ralabs worked as an extension of Levry’s product team, not as a separate vendor team. Work came from the client’s backlog, and every change went through the client’s code review.

Role	Side	Responsibility
Product Owner	Levry	Product priorities and backlog
Lead Engineer	Levry	Architecture decisions and code review
Frontend Developer	Levry	Frontend features and admin interfaces
Ruby on Rails Engineer	Ralabs	Backend features, DocuSign integration, payment and contract logic, data imports, and production support
Project Coordinator	Ralabs	Planning, reporting and communication with the client

Capacity in step with onboarding

Team capacity followed the client’s onboarding plan, not a fixed contract, and grew as the white-label partner moved into new markets.

Shared rhythm

Ralabs’ team worked in the client’s own tools and process. Tasks lived on Levry’s Jira board and ran on Kanban, a continuous-flow method where work moves across a board as capacity frees up, so there were no fixed sprints. Nazarii joined the client’s standups and reported progress there, and day-to-day communication ran through Slack.

Audit first, then build

The codebase and process audit covered test coverage, service boundaries and background processing. The DocuSign service layer was built around the same areas: isolated services, background workers and its own automated test suite.

Results:

01

1 DocuSign integration for 2 products

The enterprise tier and the Levry marketplace send, sign and store leases through the same DocuSign integration. New deployments reuse it instead of building their own.

02

20 → 40 engineering hours a week

The engagement grew from 20 to 40 engineering hours per week by November 2024. Capacity matched the pace of white-label onboarding without new in-house hiring.

03

4 languages for multi-market rollout

Contract emails are localised in English, French, Spanish, and Italian. This supported onboarding a new enterprise client in several European markets.

04

Improved payment & contract workflows

Backend fixes addressed payment schedules, incorrect charges, tax calculations, and bookings where lease signing did not follow confirmation.

05

More stable production & smaller releases

Deployment support across production and test environments helped the team move toward smaller, more frequent releases.

What the team has to say

Yevheniia
Project Coordinator

“We joined as one engineer on a part-time basis. Within four months, the client trusted us with the core of their contract workflow.”

“Ralabs’ professionalism and competency cannot be faulted.”

Sam O’Brien
Co-Founder, Levry

Work with Ralabs

Building a PropTech or SaaS product that needs e-signature, payments or third-party integrations? Ralabs provides proptech software development engineers who work inside your product team.

Let's talk

Yevhen Kulinichenko

Head of technology at Ralabs

FAQ: DocuSign API integration for leasing platforms

How do you send a DocuSign envelope on behalf of a specific manager?

Use DocuSign’s JWT grant with user impersonation. Each manager grants consent, and the platform then sends envelopes under that manager’s identity, so the audit trail shows who approved the deal. On Levry, an admin panel tracks consent per manager, and a three-tier fallback logs every case where the approving manager cannot send.

Can DocuSign handle approval chains longer than two signers?

Yes. DocuSign supports sequential signing order with multiple required roles. Levry’s integration assembles the signing order, roles, booking financials and annexes automatically, and blocks the send with a clear error if a required signer is missing. A regional manager, finance lead and director can sign in sequence.

Can one DocuSign integration serve several brands or white-label products?

Yes, if template and content logic sit behind one orchestrator. Levry’s integration routes each booking to a composite-template path or a document-based path based on its configuration. Both paths return the same result format, which lets the enterprise tier and the marketplace share one signing flow.

How do you prevent silent failures in a DocuSign integration?

Treat the send as asynchronous and confirm it. Levry creates envelopes in a background queue with seven retries and marks a booking approved only after DocuSign confirms the send. Each result states whether a failure is safe to retry, and template-access problems raise an alert.

What happens to a DocuSign envelope when a booking is cancelled?

The envelope is voided. Levry’s integration voids envelopes for cancelled bookings, including the case where the booking is cancelled before its envelope has been created.

How long does a DocuSign integration like this take?

Ralabs’ engineer made 349 commits over roughly 16 months, including substantial DocuSign work and service-layer, worker, webhook, admin, and test code. Scope drivers were impersonation, multi-brand templates, localisation and failure handling.