Skip navigation

Jive Developers

October 2012 Previous month Next month


One of the really fun things about working at Jive is we often get to work with other innovative and fast moving companies. In getting ready for Jive World this year, I had the chance to work with mgmarum from SugarCRM and mnezarati from Esna. Our goal was to show an integration with a CRM system that didn't violate what Jive co-founder and CTO matt.tucker.deactivated coined as the "One Click Rule". Essentially, this rule states that the proper use of an app must be more than just wrapping an existing UI inside of an app. This level of integration is not valuable because, with "one click", you could just as easily open the native Web page of the target application.


So we stepped back and looked at the kinds of problems that integration via an app can solve, how we might be able to leverage the activity stream, and, how being able to open an application in context (!App or !App Experiences), can provide a more effective and efficient way to bring together the disparate systems that a person uses on a daily basis. What we ended up with surprised even us! We have an incredibly powerful way to use the Jive What Matters Activity Stream to aggregate and surface workflow that spans multiple backend systems! What's even better is that because this builds on top of everything that's already in Jive, this was incredibly quick and easy to build.


The Scenario: Winning an Opportunity

Our scenario starts with a sales team doing what they do best: trying to win deal. A sales person will typically work in both Jive and SugarCRM. They'll often need to pull in information from around the company to get the win. For example, often the engineering team will have the latest details on the newest product features or the marketing team may have the latest competitive analysis. In many organizations, teams outside of sales, like engineering, do not have access to the CRM system. This makes integration with Jive's enterprise collaboration platform paramount for organizing and facilitating communication across the multitude of teams that affect the success of a deal.

The intent of this scenario is to be illustrative how we can use Jive What Matters Activity Stream to to surface a basic sales deal workflow that spans multiple enterprise systems. We'll start by having Actions posted to the stream, then use several apps to interact with the information that flows in with the stream. We'll show how to update the CRM from Jive when the opportunity is won and conclude by sending a notification to Jive with the deal information and the team's pipeline.


Automatically Posting Actions via the App Gateway

Each day, a background process running in SugarCRM sends the sales team a set of actions via their Jive What Matters stream. This contains a list of opportunities that they are targeted to close by a specific date, in this case, the end of Jive World.

daily deals.jpg

We used the Jive App Gateway so that we could easily post actions via a back end service. When the request comes in to the App Gatewy, it's signed, so Jive knows that it's valid. It also contains the Jive Id of the target instance so Jive knows where to publish it. There are lots of use cases for pushing information into Jive via the gateway. We illustrate two in this scenario; a CRON job that pulls information from a SugarCRM daily, as shown above, and a service that is invoked as the result of an event trigger e.g. an opportunity being closed.

For more information on using the app gateway, check out the doc Using the Jive Application Gateway API. The structure below is the action entry that gets posted to the Jive App Gateway. We'll refer to various parts of this throughout the rest of this post.

---- Activity Entry ----

{"items": [


        "title" : "Opportunity with the TEST ACCOUNT 1",

        "object": {

            "id": "urn:jw12sweetness:salescall:{oppId}",

            "objectType": "urn:jw12sweetness:salescall",


                    "<p>View <a jivemacro=\"appEmbeddedView\" __jive_macro_name=\"appEmbeddedView\" href=\"javascript:;\" class=\"jive-link-app-icon jive_macro jive_macro_appEmbeddedView\" __icon=\"https://;\" __appuuid=\"9417c8f9-77ab-42fd-93c4-0c7511ceae2e\" __view=\"embedded\" __context=\"{&quot;opportunityId&quot;:&quot;{oppId}&quot;}\" modifiedtitle=\"true\">Opportunity information<span class=\"j-ui-elem j-app-link\"></span> </a> from SugarCRM </p><p><a jivemacro=\"appEmbeddedView\" __jive_macro_name=\"appEmbeddedView\" href=\"javascript:;\" class=\"jive-link-app jive_macro jive_macro_appEmbeddedView\" __appuuid=\"4df62159-dfc3-47b2-865e-275e910edf25\" __view=\"embedded\" __context=\"{&quot;contacts&quot;:[{&quot;id&quot;:&quot;dummy1&quot;,&quot;displayName&quot;:&quot;Mark Weitzel&quot;,&quot;emails&quot;:[{&quot;value&quot;:&quot;;,&quot;label&quot;:&quot;Work&quot;}]}]}\" modifiedtitle=\"true\">Call this Opportunity's Contact<span class=\"j-ui-elem j-app-link\"></span></a></p>",

            "displayName": "Sales Call"


        "verb": [




        "openSocial": {

            "embed": {

                "context": {

                    "object": "{oppId}"


                "preferredExperience": [


                        "target": {

                            "type": "gadget"





            "deliverTo":["/people/2004", "/people/2125"],

            "actionLinks" : [


                    "caption": "Close Won",

                    "target": "http://{proxyOrigin}/osJumpstart/rest/sugar/entries/opportunities/win/{oppId}",

                    "httpVerb": "post"



                    "caption": "Close Lost",

                    "target": "http://{proxyOrigin}/osJumpstart/rest/sugar/entries/opportunities/lose/{oppId}",

                    "httpVerb": "post"




        "icon": {

            "url": ""


        "content": "Follow up on <a jivemacro=\"appEmbeddedView\" __jive_macro_name=\"appEmbeddedView\" href=\"javascript:;\" class=\"jive-link-app jive_macro jive_macro_appEmbeddedView\" __appuuid=\"9417c8f9-77ab-42fd-93c4-0c7511ceae2e\" __view=\"embedded\" __context=\"{&quot;opportunityId&quot;:&quot;{oppId}&quot;}\" modifiedtitle=\"true\">\"{name}\" opportunity <span class=\"j-ui-elem j-app-link\"></span></a> with {accountName} that is closing soon.",

        "jive": {

            "display": "grouped"




----- End ------


Actions for the Team

The first thing that we will look at is the behavior of Actions when they are sent to a collection of people. This is accomplished by passing an array of people in the "deliverTo" field. In the example below, this sends the Action to me (2004) and Matt (2125), which are our user IDs in the target Jive instance.

"deliverTo":["/people/2004", "/people/2125"],

This is sending THE SAME action to MULTIPLE people. The implication is that the FIRST person to act on this is taking action on behalf of the entire group of people to which the action was sent. This is great for workflows where you have a queue of things to do and team of people to accomplish them. This is a very common pattern that occurs across many different domains. For example, a development team could get a list of all the Sev 1 bugs that can be handled by any engineer, or a team of researchers may have a collection of papers to review. Of course, it's possible to make multiple copies of an action and send each to different people. Jive gives you the flexibility you need to properly surface the behavior of the back end system you are integrating with.

Interacting with Multiple Systems via !App Experiences


It's very rare that we use only one tool to get our job done. In this scenario, in addition to working with SugarCRM to build an integration into their platform, we also worked with Esna, to integrate a voice component. The Esna platform is very robust and can do interesting things like transcribe voice mail, record phone calls et. We are at the beginning of our integration efforts with them and are very excited about the possibilities. In this scenario, the Esna team created an embedded view of their application that, when opened, allows user to call the opportunity's main contact. Expanding the Action, there are two !App experience links present:

action details.jpg

The two links are "Opportunity Information" and "Call this Opportunity's Contact". First, the sales person may want to refresh their memory about the details of this account, so they would click the "Opportunity Information" link. This opens up a purpose built embedded view from our application, JW12Sweetness. This is just a quick summary of account to help prepare for the sales call.

opportunity details ee.jpg

To place the call, we use the embedded experience from our app partner Esna, by clicking on the "Call this Opportunity's Contact". This opens up the embedded view of Esna's app! We've had one application, JW12Sweetness, create an App Experience for another application, Esna. In this way, we are tying together multiple systems within a single action that comes into the What Matters stream.

esna calling.jpg


!App Experiences are created in the summary object of the Action. (Note: It's an Action because of the presence of "Action Links".) Here's a snip from the entry above.

--- Summary Object ----


                    "<p>View <a jivemacro=\"appEmbeddedView\" __jive_macro_name=\"appEmbeddedView\" href=\"javascript:;\" class=\"jive-link-app-icon jive_macro jive_macro_appEmbeddedView\" __icon=\"https://;\" __appuuid=\"9417c8f9-77ab-42fd-93c4-0c7511ceae2e\" __view=\"embedded\" __context=\"{&quot;opportunityId&quot;:&quot;{oppId}&quot;}\" modifiedtitle=\"true\">Opportunity information<span class=\"j-ui-elem j-app-link\"></span> </a> from SugarCRM </p><p><a jivemacro=\"appEmbeddedView\" __jive_macro_name=\"appEmbeddedView\" href=\"javascript:;\" class=\"jive-link-app jive_macro jive_macro_appEmbeddedView\" __appuuid=\"4df62159-dfc3-47b2-865e-275e910edf25\" __view=\"embedded\" __context=\"{&quot;contacts&quot;:[{&quot;id&quot;:&quot;dummy1&quot;,&quot;displayName&quot;:&quot;Mark Weitzel&quot;,&quot;emails&quot;:[{&quot;value&quot;:&quot;;,&quot;label&quot;:&quot;Work&quot;}]}]}\" modifiedtitle=\"true\">Call this Opportunity's Contact<span class=\"j-ui-elem j-app-link\"></span></a></p>",

---- End ----

Note: Right now, this is a pretty ugly way of creating an !App Experience because you need to know the underlying macros that Jive's RTE uses. Don't worry! We are working in improving the API so that this is isolated from you in the future. Stay tuned to the developer community for updates!


The key thing that makes this work is the app id that's contained in the HTML. This is represented in the HTML above as "__appuuid". This is the same ID that you get either through the dev console or when you create an app via the command line tool. The "__context" is the context that is passed to the application when the view is opened. If you look close, you'll notice two app Ids in the action above, one for JW12Sweetness and the other for Esna. In this way, as long as you know the UUID, any app with an embedded view can be utilized!


What we've been able to do is post one Action, asynchronously, to a team of people, that allows us to interact with multiple systems via !App Experiences, all without leaving Jive!  Being able to work with systems without losing context is a key part of turning an Activity Stream from a noisy spew of data into a powerful tool that fundamentally changes the way you get work done.



Using Action Links to Win an Opportunity

So far, we've looked at the first part of this scenario where the sales team can learn who they need to call, review the account information, and place the call. Now, let's see what happens when we win the deal. When a deal is won (or lost), we want to close this out in SugarCRM. To do this, the sales person would click on the "Closed Won" button. Taking this action sends a REST call to SugarCRM. This request is signed by Jive which enables Sugar to know which user at which instance won the opportunity! Here is how the links are defined in the Action above. We substitute in rogrammatically the {proxyOrigin} and the {oppId}.




When the request is properly received and returns a 200, the Action will be removed from the list and the value is SugarCRM is updated!

close won-1.jpg closedWonSugar.jpg


Using Notifications to Communicate Success and Close the Loop

The final step in the workflow is to notify the manager of the team of the salesperson's success an let them know a deal has been won! Again, we can post asynchronously to the What Matters stream, except in this case, we'll create a notification instead of an action. Because you can get the organization chart from Jive, it's possible that you could direct the notification to Matt's boss, a.k.a. his @manager. Here is what an incoming notification might look like.

jive won notification.jpg


Notice again that we use App Experiences inside of the notification. Because this was sent to a manager, they need to see information about not just the account, but also the overall performance of their team. Clicking on the "Team's Opportunity Pipeline" brings up a view of our JW12Sweetness application that pulls the right set of information from SugarCRM to reflect the progress of the overall team.

team pipeline.jpg


What Matters + App Experiences + Developers = Pure Awesomeness!

Jive continues to pioneer innovation that fundamentally changes the way work gets done. We're way beyond simple, noisy streams that endlessly spew bits of blah blah blah. By combining our What Matters Activity Stream with our App Experiences technology, we've created an even more powerful tool that increases your effectiveness and the efficiency of your organization by delivering information, and the ability to interact with it, directly to your fingertips, wherever you are in Jive. Opening this to developers through the Jive APIs unlocks infinite possibilities of creative integrations between multiple backend systems and Jive. What this demo showed is just the beginning. There's lots more coming!


What are you waiting for? Join us on our journey and Get Started Now!




At Jive World this year, I gave several presentations on building apps. For a few of them, I built a couple of sample apps that would show off the API and what you could do with an app. The first one that I put together is called Jive Slides App, and it's a very simple application that uses a carousel to show images. A few people came up after my talk and asked if they could get more details on the app. I promised I'd blog about the app and talk about how I built it as long as they were not too critical of the code. (There are some parts that need serious refactoring. If you're interested, I'll add you to the project!)

Getting the app installed

There are a couple of ways you can install the app. Which one you choose depends on your environment. If you are using one of Jive's sandboxes, e.g., then you should enter the following URL into the app loader:



If you are using your own community, then you'll want to publish this app using the dev console. The reason you need to publish the app is because you'll want to use the collaborative features of this app. Underneath the covers, the mechanism we use is appdata. The implication of this is that everyone that you want to share with must use an app that has the same id. Because the dev console is targeted for individual users, each time an app URL is entered, it's given a unique GUID (or app Id). Publishing this to your local community will allow others to install this from the Jive Apps Market and preserve the ID. You can find out how to use the dev console to publish an app in the documentation on the developer community. You'll use the same URL as above. Feel free to make up any & all of the necessary information for the market listing!


How that app works

When you get the app installed, click on the icon in the quick launcher. You should see the app's canvas view. The carousel's controls will "slide" you between the images. You'll notice some buttons on the top of the image. These are where you can perform "social actions" on a specific slide, e.g. Like, Dislike, and Question. Since these are social actions, they're not really much good without selecting some friends.



Select some friends

On the left hand side of the app are two buttons, "Pick Your Friends" and "Select a Group!". Both of these will populate the left hand pane with a collection of people. Both of these buttons demonstrate the use of the request pickers in Jive. "Pick Your Friends" uses the "people picker", while "Select a Group!" will use the "place picker". Either way, you'll end up with a set of people that are displayed. Underneath, you'll see the slide number they are viewing and any social action they have on that slide. In the screen cap below, Jake is currently looking at slide 5 and has pressed, in his browser, the "Like" social action button.




Awesome! Can I use my own slides?

These images that make up the slides exported from a presentation software package like powerpoint or keynote, but really, any collection of images can be used. In fact, the entire collection of images is driven by a simple json file that points to a URL of a jpg, png, or any other file type that can be the source of an img tag. You can provide your own json file by going into the app settings.

changing the index file.jpg

If you want to try another file just for fun, check out this one:

The original presentation index is here:

Note: Right now, we don't check that everyone is viewing the same set of slides (see What's next? below).


OK.... So, how does it work?

Essentially, there are three things going on here. The first is we load a file that gives us some images to scroll through using a carousel. When the user changes the image, we trap the carousel slide event. The second step is to build a json object that contains information about the current slide, including the number, and the social action. We then place that json structure in the application's data context.


Data Context is a feature in OpenSocial that provides dictionary (name/value pairs) storage for information that the application can use. You simply can get/put data sets into the data data context. To include the feature, simply require it in the app.xml

<Require feature="opensocial-data" />

When you want to add something to it, like the current slide information, it's a simple call like this:"slideShowIndex", slides);


The cool thing about Data Context is that you can register listeners on the keys. This is similar to many frameworks, e.g. backbone. The key thing to remember about Data Context is that it works with some of the advanced aspects of the OpenSocial programming model, specifically, data pipelining. We'll cover data pipeling in a later article, but for now, just think of it as a strategy to pre-populate information into your app.

gadgets.util.registerOnLoadHandler(function() {

    //The controller kicks off the process. See SSC.slideShowController constructor

    osDataContext.registerListener('slideShowIndex', SSC.buildCarouselDivs);

    osDataContext.registerListener('friendsLoaded', SSC.startRetrievingFriendSlideInfo);

    osDataContext.registerListener('friendsSlideInfo', SSC.buildSlideInfoBadges);

    osDataContext.registerListener('viewerFriends', SSC.initializeFriendsList);

Note: Because this is a relatively simple app, one thing that I did, which a framework like backbone.js solves, is that the data & view is commingled together. Eventually, we'll either rewrite or refactor the app to be a bit cleaner. Regardless, the key point is that data context provides a mechanism for event driven programming of apps.


Once we have the information about the current slide, we store that in app data. App data is another part of the OpenSocial programming model that is, essentially, a store of persistent information that an application can use. The interesting thing about app data are the access control rules for who can read and write the data. Specifically, each person can write their own app data and can read everyone else's app data. This is a perfect use case for the simple slide viewer app. I write to app data what slide I'm on and whether I like or dislike it.

SSC.setCurrentSlideInfo = function(slideInfo) {

    osapi.appdata.update({userId: '@me', data: {"newSlideInfo":slideInfo}, escapeType: opensocial.EscapeType.NONE }

    ).execute(function() {

            console.log("app data updated" + slideInfo);




In the function above, I'm setting my slide info in the key "newSlideInfo". The "@me" is shorthand for the current user. Specifically, Jive will substitute in your user ID whenever it encounters this moniker. the "EscapeType.NONE" tells Jive not to escape that's contained in the structure. Executing this function actually stores this information in Jive!


Now the fun part. When the app initializes, it sets itself up a polling cycle for every two seconds or so. What do we do every two seconds? Get the app data!

osapi.appdata.get({userId: userIds, keys: ['newSlideInfo'], escapeType: opensocial.EscapeType.NONE}).execute(SSC.refreshFriendSlideInfo);

When we retrieve the app data, we read the "newSlideInfo" key. This gives us structure back where each property is a user Id. The value of that property is that user's current slide information! Once we retrieve this information from the server, the easiest thing to do is put it into the app's data context. Why? Because we register listeners on the data context to fire when we put in the data we pulled down from Jive. The listeners that are registered will look up the user in the side panel and decorate the avatar with the current slide number and the social action.


What's next?

And that's it! We've been able to build a social application without requiring any backend server. We've used the Jive and the OpenSocial APIs to share data between users. What's next? Well, you tell me! This app is pretty basic. However, I've got some fun ideas if you are up for a bit of exploration and learning, like:

  • Sharing of slide index files so that you can give your friends the slides that you should all view.
  • Follow the leader: Designate one person as the "leader" all other viewers will follow his slide navigation.
  • Link jive discussions to a slide: Start a discussion based on a slide and pull in discussions and display the text.
  • "Chatty Kathy": Post an activity when you like a slide.
  • Make sure everyone that is sharing is viewing the same set of slides (based on the slide index file).

If you just want to get the source code, then you can grab it off of Jive's public git hub repository. However, it's more interesting if we build this out together. If you are interested, then I'll simply add you to the project in apphosting. (You'll need an account for Jive's Developer Services. I can then just say, "jiveapps sharing:add <your id here>".) This way, you can get some hands on experience building & working with the API!

As part of the OpenSocial specifications, the Jive Apps framework supports a signed proxy request for initial rendering to allow Jive Apps to be pre-rendered in the server side when the Jive instance is trying to fetch the content from the origin server.


By setting the authz attribute in the Content element of the Jive Apps' app.xml file, it lets the Jive as OpenSocial container to know what authentication protocol desired for the App's proxy content fetching.


For example:

<Content type="url" href="" authz="signed" sign_owner="true" sign_viewer="false"></Content>


If authz is set to "signed", based on the OpenSocial specefications , the Jive instance will do signed fetch to the App origin server as part of content proxy requestwith additional information that could help the App server to get more context to generate HTML markup dynamically in server instead of making additional call from client browsers with JavaScript.


The additional information includes:

  1. opensocial_viewer_id - The ID of the current viewer, which matches the getId() value on the viewer person object.
  2. opensocial_owner_id - The ID of the current owner, which matches the getId() value on the owner person object.
  3. opensocial_app_url - The URL of the application making the request. Containers may alias multiple application URLs to a single canonical application URL in the case where an application changes URLs.
  4. opensocial_instance_id - An opaque identifier used to distinguish between multiple instances of the same application in a single container. If a container does not allow multiple instances of the same application to coexist, this parameter may be omitted. The combination of opensocial_app_url and opensocial_instance_id uniquely identify an instance of an application in a container.
  5. opensocial_app_id - An opaque identifier for the application, unique to a particular container. Containers that wish to maintain backwards compatibility with the opensocial-0.7 specification may include this parameter.
  6. xoauth_public_key - An opaque identifier for the public key used to sign the request. This parameter may be omitted by containers that do not use public keys to sign requests, or if the container arranges other means of key distribution with the target of the request.

One of the exciting things that we get to do at Jive is work hand in hand with lots of startups with killer ideas, innovative technology, and tons of creative passion. One of the big reasons motivations behind the Jive Apps Market is to make is easier for our customers to take advantage the incredible amount of innovation that's happening in the industry. Now, we want to make it even easier the these agile startups to start working with Jive!


Introducing Jive for Startups!

Jive for Startups is a new program designed to get the world's best social business platform into the hands of the world's best startups! Jive for startups will allow qualifying companies to use Jive for free for up to 100 people. This isn't a demo environment or a sandbox--we've got plenty of those. It's a full fledged Jive environment running our latest cloud release. By using Jive, you will get a complete understanding of how we are changing the way work gets done.


What do you have to do to qualify?

Simple. Build an integration for the Jive platform! Typically, this will be integrating your killer idea into the platform via a a Jive App, but it does not have to be. Apps remain the fastest and recommended way of extending the Jive UI. However, the V3 API provides almost complete coverage platform. It's now possible to start building some very powerful integrations that leverage the REST APIs. In fact, we are starting to see some very interesting solutions come forward that combine the REST APIs for server integration along with Apps for UI integration. The sky, if you will forgive a bad pun, the cloud, is the limit! The more you understand Jive, the better you can integrate your ideas and technology. If you are a company that is interested in using Jive and building integrations or apps, then please fill out the attached form and send it to me (mark.weitzel). (You can also be old school and fax it in to the number in the PDF.)


The day you get Jive!

At Jive, we are passionate about changing the way work gets done in the enterprise. But we know we can't do it alone. We need innovative partners that share our drive and vision. In short, we need you! So join us and get your Jiveon today!

album_icon_medium.pngSleep was lost, caffeine was consumed copiously (plus some beer as balance) and we weren't sure at all times that the experiment of building an app in one day based on JiveWorld audience choice was an entirely sane idea. But we did it -- the team successfully built and delivered the Jive Albums app. If you're a Jive cloud or Jive 6 user, you can install the app from the Jive Apps Market immediately.


So, why did we do this?

  • We wanted to show just how far the Jive platform has come over the last year. With all-new versions of the REST and Javascript APIs and huge improvements to how Jive Apps can integrate more deeply into the user experience, right now is an amazing time to build on the Jive platform.
  • We loved the idea of building something directly based on the votes of Jive customers.
  • We hoped it would be kind of fun, and it was!


For a peak into the Hackathon process and results, check out the following video:



And some additional behind-the-scenes footage at The specified item was not found. and JiveWorld12 Hackathon - Day 2 - Developer Check-In.


Thank you to the Jive engineers that made the hackathon a success and to all the Jive customers that stopped by the hack area to ask questions and wish the team well. We'll see you at JiveWorld13!

Jive Apps Development 102

Posted by shoemaker Oct 11, 2012

Today mark.weitzel and I presented at the Apps Development 102 session. We covered some real-world examples of how Thomson Reuters uses the Jive application platform to replace our legacy portal, and outlined what goes into developing an app. We had a great audience who asked a lot of great questions. Here are some of the main points we covered:

  • Getting involved in the Jive developer community.
  • Demonstrated the types of applications Thomson Reuters migrated from the legacy platform.
  • Retrieving data from a RESTful API.
  • Demonstrated many of the features of the Jive and Open Social platforms, including !App mentions, posting to the activity stream, the Dev Console, and integrating content from your social circle + connections on Jive.
  • How Apps will evolve from 5 to 6/Cloud.


If you have follow up questions or want to learn more, we encourage you to attend the Jive Apps Development 202 session from 1 - 2 PM in Garcia 5 (3rd floor). mark.weitzel and shoemaker will also be available at the Ringside with the Experts session from 3:30 - 4:40 PM in Garcia 6 (3rd floor) for one-on-one discussion. You can also connect with us on Twitter: Mark (@weitzelm) and Brian (@shoemaker).


If you'd like to download the Location Demo we walked through during the session, you can find it on GitHub. A description of the Jive and OpenSocial components used in the app can be found in the "read me" file.


Finally, we encourage you to check out the Jive Community to connect with other app developers. This is the best resource to get answers to your technical questions, learn more about Jive and the OpenSocial platforms and get involved with the Jive developer community.

A couple hours earlier on mainstage, mark.weitzel and I announced the JiveWorld12 Hackathon. For the next ~30 hours, a small team of engineers at JiveWorld will be building an app from prototype stage all the way to delivery. Because yeah, even though we're in Vegas, what else would we do all night? As soon as we're done, the app will be immediately published in the market and be available to all Jive 6 users free of charge.


Many of us at Jive love Kickstarter, so we wanted to riff on the concept a bit for the hackathon. In a quick video, we showed mockups for three different apps that we thought Jive users would love. Mainstage attendees then voted in real-time for which app of the three they wanted funded and built. The crowd has spoken, and so we're off and running building image galleries for Jive. More news and pictures soon as we make progress!




I'm excited today to announce that Jive has taken another step in enabling our ecosystem with the introduction of a new sandbox for developers,! This sandbox includes the Jive V3 API, the most powerful programming model available for integrating with a social business platform. Using the V3 API, you have access to all of the content types inside of Jive, including ideas & tasks. The What Matters Activity stream is at your "coding" fingertips. Developers can create custom streams, actions, and notifications. Admins users have the ability to create users and places, as well as access to Jive's system properties.


Free to all Jive Developers! is freely available to all Jive developers! The sandbox uses your Jive Community credentials as your username & password, so if you're logged in here, you can start using the sandbox now! If you need a developer account, you can sign up at You can learn more about developing apps and integrating with Jive in the developer community. The doc Hey, I'm new here, how do I get started?, is a quick guide to help you get up and running fast!



Today I'm excited to announce the re-launch of Jive's Developer Community Web site! We've given it a complete overhaul and made it easier to find information, learn about the Jive platform and APIs and engage other developers and app partners. This new developer site reflects the spirit, energy, and excitement we have for developer community and the larger Jive ecosystem.


Since you're reading this, you've realized that we've merged the old developer community into our Jive Community. The new Jive Developers space is where you can work with the Jive Engineering team to get answers to your questions, learn more about how to integrate with Jive, build apps, and much more. You can check out the The specified item was not found. space to learn more about how the market works.


Want to know more about a specific app? Each of our app partners will have their own group where you can engage them directly about their app, create ideas for improvement, or start discussions for new requirements. Here are a few examples from The specified item was not found. and The specified item was not found..

Screen Shot 2012-10-04 at 12.57.27 AM.pngScreen Shot 2012-10-04 at 12.57.23 AM.png

And we're not done! We're going to be brining more technical content your way. More sample apps to help you get up and running faster with your own apps. More app partners on line so you have more choices in adding capability to your Jive instance. We will continue the innovation that you've come to expect from Jive by improving the APIs, making integration easier, and accelerating your ability to build on our platform. The fun is just beginning.



So join us, and brew up something awesome!

If you're IT Manger or developer and you find yourself at Jive World this post is for you. It's chock-full of goodies to help you get the most of your time in Vegas. Of course, if you have any questions while you're there, you can always ask me or the other Jive Engineers at Jive World. We'll be at the bar---The Genius Bar that is. So, here are some quick tips...


Find our App Partners

One thing you'll want to do is find our app partners. Every one of them has built an app that's live in the Jive Apps Market. Many of them have updated their apps to use the latest capabilities of the platform, including !App Experiences. They are a great resource to find out how easy it is to build an app. Because these apps are so diverse, you'll have an opportunity to get different ideas on how to integrate your own systems into Jive using apps.


Ask Questions!

Stop by the Genius Bar and ask questions. This is probably one of the best opportunities you'll have to ask a question to one of the Jive Engineers. We're excited about making our customers successful and hearing from you first hand and helping you get an understanding the platform so you can better tackle your problems is win-win. And don't forget we've got the Jive Developer Community as well! You can post a question here anytime!


Attend the Developer & Architect Sessions

We've got some great content lined up for developers this year. I'm super excited about all of the sessions and know that you'll walk away from Jive World armed with an incredible amount of technical information and ready to build your first app! Here are some of the things I'm particularly looking forward to.

  • shoemaker will be presenting in the Apps 102 session on Thursday. He's got has some great practical advice on how and where to get started building on top of the . Make sure to ask him about the "developer challenge" that he had his team undertake. It was a creative way to challenge the team to learn more about the Jive platform.
  • Understanding how to make your app more user friendly will increase adoption and make your users happy. This year, christopher.rivard will be talking about successful design patterns. Many of these patterns are learned first hand from Chris's work designing the Jive UI.
  • Standards are important to every enterprise. They are often the backbone of many of the systems that we use on a daily basis. Jive's App Framework is built on top of OpenSocial, the only industry standard for social business applications. John LeBlanc will be talking about the importance of standards, especially OpenSocial, and how it plays a key role in moving the industry forward.
  • Writing your Jive App is only the first step. jacob.wright & ryan.tyer will give you some key insights on how to get your app ready for production and manage it once you let it loose in the wild.


Share & Have Fun!

This probably goes without saying, but...  Whether it's building apps, increasing engagement, or finding the best third party solution, Jive World is full of people trying to accomplish the same goals. I never cease to be amazed at the ingenuity of our customers. Being all in one place is a fantastic opportunity to learn from their experience and share yours. Look for opportunities to talk about the killer technical solution you're building, the problem that you can't seem to figure out, or the most cool thing you've seen at Jive World.


And don't be shy about getting your laptop out and showing off your code either!


See you in Vegas!

Filter Blog

By date: By tag: