Media labs

Media Innovation Mapping research seeks to understand innovation and the organisational structures that exist with news publishers, content producers, research institutions and clusters and technology providers.

It is a collaboration between the the World Association of Newspapers and News Publishers’ Global Alliance for Media Innovation, the Media Innovation Studio at UCLan, Ubilab at PUCRS university in Brazil, Norway’s NxtMedia innovation cluster and Stibo Accelerator based in Denmark.

The project plans to ‘map’ innovation labs, clusters and a selection of projects globally to establish insights into a number of factors. These include how the media labs are structured, and why they were created, what type of methods they use to innovate, their products and services and stories of their successes and failures.

Want to tell us about your Media Lab? Or to talk to us about the innovation process in your company?
Contact us

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