Based on this description, an enterprise mashup might seem similar to other application development and integration technologies like ESBs, BPM, business intelligence, portals, or even development languages like Java. But enterprise mashups fill a niche in the IT bag of tricks and there are a few unique characteristics that separate enterprise mashups from their software cousins:

User-centric - Mashups are created for the consuming user, often by the users themselves. Unlike terse black-box back-end integration tools like ESBs, BPM, and BPEL, users can connect the data dots themselves. This implies many user-centric qualities:

• Normalization of the data sources into a seamless virtual cloud of look-alike services
• A visual drag-and-drop UI to wire the services together
• A robust set of actions to tailor the output to the individual user's needs
• Support for collaborative work such as tagging, searching, and sharing

Without these characteristics, we're back to sending the users to IT for more development.

Bite-Size - Mashup users typically deal with small amounts of knowledge-oriented information (as opposed to IT-managed integrations that typically deal with large amounts of transactional information). Users are, in effect, performing micro-integrations that take minutes to hours to complete unlike major integration or BI efforts that have timelines of months to years. Most mashups are connecting to a limited set of services; more than six or seven in any mashups and you should likely be considering another way to approach the problem.

Web-accessible - Increasingly popular standards-based interface/communication technologies (such as WSDL, REST, and RSS) make mashups possible. But the format is only part of the story. Mashups are built on data that could reasonably be displayed quickly in a Web browser or, more precisely, data that doesn't require too much manipulation for the user to make sense of it. And the inverse is true as well: once built, mashups inherently produce information results that also conform to the "ready to be read in a browser" formats. And because of this portability of source data, mashups are most relevant when they involve a dynamic combination of external data sources and internal data source (public and private).

These qualities certainly differentiate mashups from long-cycle IT-driven technologies like ESBs, BI, BPM, and enterprise portals. Interestingly, mashups also compliment these technologies by either consuming their outputs from them (ESB) or providing inputs to them (BI, BPM, portals).

Enterprise mashups are still new enough that few qualified and quantified ROI studies exist, but anecdotal evidence indicates that the benefits of enterprise mashups can be substantial. For business users, enterprise mashups address so called long tail information needs that are too infrequent (low latency) to justify big IT efforts. And rest assured there's substantial value in mashups for IT as well, as they improve the return-on-assets of the existing systems mashups are built on. And that's why they compliment SOA efforts so well.

Planning for SOA-Driven Enterprise Mashups
Politics, Mashups, and Your SOA
Let's face it, SOA is plumbing. Nice, shiny, efficient plumbing to be sure, but still plumbing. And your average business person (think sales manager, marketing director, finance officer, or customer support rep) could care less about it. In fact, if they think about it all, they probably just hope it stays right where it is: out-of-sight and running quietly. These same business folk probably appreciate the marble floors, wood-paneled doors, and brass fixtures that surround this plumbing much more. In other words, they like that bit of "stuff" that actually frames the plumbing and brings it to life.

The ROI of SOA is difficult, at best, to define and measure. While experts differ on issues like the importance of SOA ROI, how to calculate SOA ROI (if at all), and why we don't have more of it, they all seem to agree on one thing: Enterprise-wide support for SOA hinges on the ability to demonstrate value to the business at large - more growth, revenue opportunities, and all that good stuff. And that's where enterprise mashups can greatly enhance the ROI of an SOA.

Enterprise mashup implementations drag the SOA out of the proverbial IT basement and onto the end-user's desks. This is not only highly visible but it's user-driven, giving IT a way to enhance that elusive SOA ROI, give users an ownership stake in the SOA, and improve IT contribution to leading-edge business needs. But historically IT and business don't have a great deal of experience in working harmoniously (particularly in dynamic areas like this) so the first lesson of SOA-driven mashups is simple: be prepared for political and social changes among and between the business and IT groups that are involved in your SOA-driven mashups. Mashups don't mean an end to IT but they certainly do proscribe a very different kind of role.

Mashups Change the Nature of SOA
Beyond the changes in the people dynamics, there are a number of very practical synergies between mashups and your SOA that have implications for your SOA design. Each of them holds lessons and messages for the SOA architect. The most important of these synergies include:

1. Virtualization: Mashups can help create normalized "virtual" services from sources that haven't been "SOA'd" yet. It's no secret that SOA efforts can take years. Until the formal SOA magic has been applied everywhere, a quick, standardized service can help users get started earlier than otherwise.
2. Right-sizing: Mashups let users "right-size" the granularity of services. Now IT doesn't have to guess/study/analyze whether a service offers data that is "too specific," "too general," "too dated," or "too cold."
3. Collaboration: Mashups let users share their resulting services, making them a part of the service-generating network. Now IT doesn't have to do it alone.
4. Visualization: Mashups let end users visualize the SOA in graphs, charts, tables, and maps. Instead of hoping the aging corporate portal has a place/way to get services visualized in the way(s) the users want, each user can do it to meet their own ever-changing needs.
5. Micro-Combination: Mashups let users join in data from outside the enterprise. Today's SOA efforts are largely inwardly focused. But users often want to include external data in their work. Mashups don't care and good mashup software makes the actual location of a data service irrelevant.

Leverage Your SOA Security for Your Mashups
The synergies between SOA and mashups are only the beginning of the story. Mashups must play nicely in the larger, typically-complicated security and governance enterprise ecosystem you've built around your SOA. From our original enterprise mashup definition and the interaction patterns above we can extract the following important security/governance requirements:

• Have a Bridge: To truly leverage your ever-growing list of SOA services, you'll want an easy-to-use bridge that moves SOA service information between your SOA registry/repository and your enterprise mashup service repository. You do have a SOA registry/repository already, don't you?
• Propagate Credentials: Your enterprise mashups must manage user authentication inherently, delegating credentials to the appropriate identity management system and all mashed-up services. Hence, your enterprise mashup solution must also let the mashup creator specify desired entitlements. And all of this must be treated uniformly and seamlessly when mashing up internal or external services.
• Standardize and Deploy Incrementally: Your enterprise mashup must propagate credentials in the format the source services require. And this security/credential propagation must be built into the architecture because standards are weak here. Of the four service types, only JDBC/ODBC-compliant databases and WSDL (via WS-SecurityPolicy) have a somewhat "standard" credentials format, albeit ill-adopted. So your enterprise mashups must have the flexibility to pass user credentials in whatever form the service providers require, perhaps leaving a placeholder for new standards or custom formats.
• Accommodate Syndication: Mashups are portable and you must imagine your mashup embedded in a Web 1.0 portal (such as BEA and Oracle Portal), in a Web 2.0 interface (such as Netvibes or Pageflakes), or your next-generation destination like an iPhone. Every mashup widget must maintain portable security and governance no matter where it goes.