Home
Salesforce and PropertyBase Integration

Salesforce and PropertyBase Integration

to : Gunner integrated JIRE's open source-backed Property Management System with Salesforce's proprietary one, so JIRE could seamless enjoy the benefits of both.

Showcase & Media

Video Case Study

Post Mortem Discussion

Architectural Diagrams

Check out architectural diagrams of this project

Problem

What was the problem to be solved?

JIRE purchased a subscription to PropertyBase, which is Salesforce's real estate plugin.

Unfortunately, the model of integration Saleforce had in mind (where the website would be generated from their end) turned out be unfeasible, so JIRE needed a way to integrate with its newly purchased technology.

Solution

What was the proposed solution?

Gunner proposed using the Salesforce API to push data from the Open Source CRM to Salesforce and maintain the existing platform.

This would give JIRE the flexibility it needed from a product standpoint while still feeding the data into PropertyBase, which would keep the CRM functionality JIRE desired in the first place.

Challenges

What challenges arose during the project?

PropertyBase turned out to be more of a bolted on afterthought than a first-class citizen in the Salesforce world.

That meant, once JIRE was under contract, the Gunner team didn't get much support help and was left figuring out how to integrate with the Salesforce API.

"It was kind of like 'Well, it's your problem now,'" Gunner founder and CEO, Cody Swann, said. "The minute they heard we weren't doing things the exact way they wanted it done, was the minute we were on our own."

Testing was also a challenge because JIRE didn't have a test environment for PropertyBase and couldn't always tell if the data was correct.

"Unfortunately, it was kind of 'Fire and Fix,'" Swann said. "We just had to make sure that, if discrepancies were found, we could easily fix them."

Technical

What was the technical approach to the project?

Gunner needed a way to keep the data in the two platforms synced without help from Salesforce and without a testing environment.

From a technical perspective, this meant the team needed a way to be able to repeatably run large data syncs but also be able to do them in a way that they could be backed out since it was dealing with live data.

"Fortunately, Amazon Web Services has a number of technologies to make that a bit easier," Swann said. "We needed to create an initial process that we could run over and over and over again until the data on both sides was perfect."

To achieve this initial sync, Gunner had to get all the data in the Open Source PostgreSQL database that was hosted on Amazon RDS into Salesforce using the Salesforce Sales Cloud REST API and format the data so it would conform to the PropertyBase specifications.

"The real tough part was that Salesforce imposes a hard rate limit on their API, so we couldn't just move all the data at once," Swann said. "That's where Amazon SQS came in handy."

Instead of making the calls in real-time, each sync operation (one per listing) was placed into an SQS queue and retrieved via a Node.js powered AWS Lambda function in an interval that was spaced out enough to not hit the rate limit.

Once the data was in sync, it needed to stay in sync.

This meant that the brokers who used PropertyBase needed to see the latest data from the website database without having custom data they entered get deleted.

"In theory, this should be really easy," Swann said. "During the initial sync, we created an id schema that would tie the two systems together so when data was entered or edited on the Refinery side, it would update the corresponding data on the PropertyBase side. But, of course, it wasn't that easy because the Salesforce API fails quite often and you can't keep retrying or you'll hit their rate limit."

In practice, what the team did was created an API of their own which was fronted by Amazon API Gateway.

The gateway was connected to another Node.js AWS Lambda function which would get called whenever data was created or altered in the Ruby on Rails Content Management System.

If a failure occurred, the Node.js function would place a marker in another SQS queue which would retry the operation at a later time that would not jeopardize the rate limit.

"We've worked with Salesforce before," Swann said. "But this was, by far, the biggest pain in the butt."

Management

What was the project management approach to the project?

As with most projects, Gunner took an Agile Scrum approach.

This was the first time the team had worked with PropertyBase, so the developers started out with two Research Sprints to get a good understanding of how it worked.

Once the team had a good grasp of the API, it began the usual approach:

1) One week function sprint where we added new functionality

2) One week QA sprint

3) One week bug fix sprint

Repeat until finished.

Architectural Description

What platform was built for this project?

The main JIRE app runs Ruby on Rails on two AWS Elastic Beanstalk environments.

The web environment leverages Elastic Load Balancing and both rely on AWS Auto Scaling to create a Secure and reliable platform.

The Node.js portion of the platform is separate and build using the Serverless Framework.

Finally, Gunner implement a Continuous Development, Git-based, DevOps framework, leveraging technologies such as AWS CodeCommit, AWS CodeDeploy, AWS CodePipeline and AWS CodeBuild.

As always, Gunner created a separate AWS account for the client and manages it from the parent organization.

Lessons

What did you learn from working on this project?

The team learned a lot about Salesforce and PropertyBase in particular, but there were other lessons that were reinforced along the way.

"First, when doing any time of data migration, you need to make sure you can run it over and over and over again without a lot of setup work - script it," Swann said. "Secondly, and any good developer knows this, don't assume anything is going to work and with Salesforce, plan on it not working."

Benefits

How did this project benefit the client?

After the project's launch, JIRE was able to use a single source of data while still leveraging the benefits of PropetyBase.

This allowed the marketing team to enjoy all the benefits and familiarities of Refinery while giving the brokers the power of PropertyBase.

Most importantly, work was not duplicated as data was kept continuously in sync.

Why Gunner?

Why was Gunner selected for this project?

Gunner has worked extensively with the Salesforce API, so we were immediately familiar with how to get up and running, so we put together a demo for JIRE that illustrated our proficiency with Salesforce.

Proficiencies

What tools, techniques and methodologies were used on this project?

[object Object]

Agile

Agile software development refers to a group of software development methodologies based on iterative development, where requirements and solutions evolve through collaboration between self-organizing cross-functional teams

[object Object]

Amazon API Gateway

Amazon API Gateway is a fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale.

[object Object]

Amazon SNS

SNS is Pub/Sub messaging and mobile notifications for microservices, distributed systems, and serverless applications.

[object Object]

Amazon SQS

Fully managed message queues for microservices, distributed systems, and serverless applications

[object Object]

AWS Auto Scaling

Add or remove compute capacity to meet changes in demand

[object Object]

AWS CodeCommit

AWS CodeCommit is a fully-managed source control service that hosts secure Git-based repositories.

[object Object]

AWS Elastic Beanstalk

AWS Elastic Beanstalk is an orchestration service offered from Amazon Web Services for deploying infrastructure which orchestrates various AWS services, including EC2, S3, Simple Notification Service (SNS), CloudWatch, autoscaling, and Elastic Load Balancers.

[object Object]

AWS Lambda

AWS Lambda lets you run code without provisioning or managing servers.

[object Object]

Elastic Load Balancing

Achieve fault tolerance for any application by ensuring scalability, performance, and security.

[object Object]

Git

Fast, scalable, distributed revision control system

[object Object]

Node.js

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications

[object Object]

PostgreSQL

PostgreSQL is a powerful, open source object-relational database system

[object Object]

PropertyBase

Propertybase is a cloud-based Customer Relationship Management and marketing solution that caters to Real Estate brokers in businesses of all sizes.

[object Object]

Ruby

Ruby is a dynamic, interpreted, open source programming language with a focus on simplicity and productivity.

[object Object]

Ruby on Rails

Rails is a web application development framework written in the Ruby programming language

[object Object]

Salesforce Sales Cloud

The API for the world’s #1 CRM sales app

S

Scrum

Scrum is a framework for project management that emphasizes teamwork, accountability and iterative progress toward a well-defined goal.