Inspiration

A fellow founder from the Belgian startup community asked me for help with his Context.IO Apps challenge submission. He is not a developer but he is an amazing hustler, so I decided to help him.

From my own experience I know how hard it can be for a non-technical startup founder. That is why with my colleagues we built a Graphical UI for Context.IO in Drupal to help anyone who can click their way through a configuration screen make their own email applications.

Potential impact

There are just under a 100 thousand users actively contributing to the Drupal project. With the Context.IO module it is now really easy for them to create email applications.

We expect that the open sourced Context.IO module will have some or all of the following impact:

  • Some of the sites that currently use Mailhandler will switch over to Context.IO
  • Some of Drupal's 502 distributions (e.g. ticketing packages) will start including the Context.IO module into their downloadable package
  • Site builders will start using the Context.IO module in their new projects
  • Administrators will develop email applications for their organisations

When you choose our submission for the competition you give us the funding to further promote it in the community.

What it does

Instead of making a single app, we wanted to create a platform on top of which other people, even non-developers could innovate. That's why we built a Drupal module that we've open sourced. We've also built an example implementation that uses the module to address 2 problems we had in our company.

The Context.IO module lets you set up feeds in Drupal that will import emails, or data inside your emails into a site. To do so you don't need to write a single line of code. You can use our module to make applications that do any or a combination of the following:

  • Import emails that fulfil certain criteria from your email archive
  • Import emails as they arrive in your mailbox
  • Extract information from email bodies (this currently requires regular expressions, I guess that qualifies as code)
  • Share this information with a selected group of trusted parties that get access to your site
  • Do certain actions (e.g. schedule, or send an email) when you receive an email that fulfils certain criteria
  • Create users in your site every time you receive email from a new address, or when an email gets forwarded

Drupal already has a module to import emails: Mailhandler. Drupal.org knows about 2,352 sites that currently use the module and it has been downloaded 62,105 times. The Context.IO module that we built however is superior over Mailhandler for the following reasons:

  • Mailhandler doesn't provide options to search and filter emails
  • Mailhandler's primary use case is to import mail as it arrives in a mailbox, not to process emails that have been archived.
  • Mailhandler requires you to provide login credentials to the site, and can't currently request access using oAuth. As a result it's only really fit for single mailbox applications (e.g. a "reply to" comment on a forum). So not really for applications that consumers can grant access to their mailbox to.

Drupal is one of the leading open source CMSs and is popular with a really large audience ranging from technically savvy consumers all the way through to enterprise organisations (e.g. https://www.whitehouse.gov/ runs on Drupal). While it is comparably easier to set up a Wordpress site, Drupal is more flexible. It's with this flexibility in mind that we built the Context.IO module.

How we built it

The module is conceived as a building block, compatible with Drupal's massive ecosystem of modules. Since it's a module that implements the Feeds architecture, it allows site builders to configure:

  • A fetcher that uploads emails that fulfil a set of search parameters
  • A parser that extracts information from inside the email into separate fields, to store structured information
  • A processor that maps the information into native Drupal objects and their fields (e.g. nodes, users, comments)

Challenges we ran into

Overall the API was easy to use, but we had some difficulties with the implementation of the attachment API. We've filed a bug for it on the GitHub project. In the beginning there were some synching issues with my inbox, because of which we couldn't fully test the body import function.

Accomplishments that we are proud of

  • We've finished the Context.IO module in under 2 weeks.
  • The site that we use in the demo video was built in less than 4 hours.
  • The module is really powerful and plays nice with Drupal's contrib modules. We are really excited about it's potential.
  • In 5 days we had 85 downloads for the module, and it's already reported in use on 3 sites. This is really fast adoption, that I haven't previously seen in my 10 year long Drupal carreer.

What we learned

  • We had a dependency bug with the Context.IO library and our developers had to freshen up their knowledge about dependency management with libraries in Drupal.
  • Prototyping in Drupal goes really fast and is super fun (I guess that wasn't really news, for us at least)

What's next for the Context.IO Drupal module

  • We've published a blogpost about the competition and the module to the Planet Drupal (an RSS feed for the Drupal community). We will be following up with another post about the demo video (also here attached). We'll do another video that is targeted at site builders.
  • We would like to talk with the Context.IO team about community outreach programs in the Drupal community
  • We want to still implement attachment handling
  • We want to set up a beta invite signup page to check for interest for the prototype that we built. We believe there might be interest for it as a customisable B2B solution.

Maildispenser demo implementation

Selectively share email

Maildispenser is an application that helps people selectively share emails. With it you can set up filters that will automatically upload emails into an online archive space. Each archive space can be shared with a group of people of your choice. With it, you no longer need to forward your emails or give access to your mailbox. Access permissions are granular: other people only get to see the emails they need, and when they no longer need access you can revoke their permissions. Unlike the native gmail filters that will only forward when they arrive to your inbox, Maildispenser can also help you share old emails.

Invoice sharing

Earlier this year my assistant who helps me processing my expenses went on pregnancy leave. In the past years I had set up a large number of email filters in Gmail that forwarded invoices to her, now I not only had to redo those filters, I also had to forward a number of invoices that hadn’t been processed yet. If you work with one assistant this is a bit of a hassle, if you work with a number of different people from odesk for example, this can be enough hassle to undue whatever time savings you made using an admin in the first place. You could maybe solve the problem if you forward these mails to a separate mailbox, but then you have to keep changing your credentials for it.

With Maildispenser, you can set up a space for your invoices, you can either define a catch all filter, that will upload any email that mentions the word invoice. Or you could define individual filters that only upload emails that originate from a certain address and have a specific type of title, to upload invoices from each of your vendors separately. Once the system is set up you can then give your assistant access to your invoice space. When they are finished with the job, you can revoke their permissions.

Email archive

A few months ago we fell out with a customer, as a pre-seed startup they had run out of money. They threatened us with a law suit and played other tricks to try to make us do more and more work for ever shrinking amounts of money. When we didn’t give in, they deleted our sprintlogs and kicked us out of their ticketing system so that we wouldn’t have proof of the work we did for them. Luckily we had kept the notifications we got from their ticketing system. Email threads spread over a few different inboxes, however, are not all that great when you need to piece together what happened in a project.

With Maildispenser you could in this case reconstruct the comments history from the ticketing system. You can set up a space and add emails from all the developers that worked on the project. With a special field that extracts the ticket number from the email title, you could add the comments in chronological order to the right ticket.

Who we are

Pronovix is a consultancy that supports developer-focused software companies:

  • We integrate APIs from SaaS services like Context.IO, Livefyre, Gitlab and Brightcove with open source software (primarily Drupal) to make it even easier for developers to use those services.
  • We provide maintenance and community support for the integrations.
  • We help promote the integration in the developer community through blogposts and community specific outreach programs that play nice with the community and that are built on top of sometimes less obvious communication channels.
  • We build websites for these companies that integrate documentation into their marketing site. This increases their search ranking, reduces support costs and improves ROI on sales.

Built With

+ 25 more
Share this project:
×

Updates

Kristof Van Tomme posted an update

We are thrilled to be first runner up in the Apps challenge! To celebrate we are preparing a new release of the module. We are also planning a community outreach program that we will fund with the prize money. Stay tuned for more information!

Log in or sign up for Devpost to join the conversation.