So You Wanna Be a Rock Super Star?

One important factor of running a company, as well as becoming a rockstar developer, is efficiency. Here at LevelTen we are constantly tweaking and revising our development processes to become as efficient as possible while still providing clients with the best possible solution for their website needs.

LevelTen has developed a number of internal tools to help standardize work across our small team of developers. These tools not only help with efficiency, but also with work consistency, and code portability. What this actually means is that rather than reinventing the wheel each and every time a client requests a common feature, like a blog, we can simply copy it from a repository of features, and tweak a few things to meet our clients' needs. While this requires a lot of time and thought to develop these features in such a way that is reusable, it dramatically reduces the amount of time spent per client to build them out.

Here I will talk about a few of the Drupal modules, and other tools we use to standardize our internal development workflow.

Features

http://drupal.org/project/features

Features is the heart and soul of creating a packaged set of reusable functionality. In case you're unfamiliar with this module, the general idea is that it allows you to export configuration settings into a "feature" which is really just a module. The point of this is to get it out of the database and into the codebase which will allow you to store things like views, and content types, in a version control system rather than the database. 

LevelTen uses Features to package specific functional use-cases, like an entire blog, in such a way that the functionality is general enough to be reusable across multiple client sites as a solid foundation for customization. 

Twitter Bootstrap

http://twitter.github.io/bootstrap/

http://drupal.org/project/bootstrap

Twitter Bootstrap is an awesome Less/CSS framework for creating really beautiful, responsive, and very consistent looking websites. Out of the box, it is nothing more than some basic Less and javascript libraries for things like form fields, buttons, drop downs, accordions, and various other common page elements. However, if you're at all familiar with theming a website and writing CSS, you probably know how frustrating it is to try to change the styles on a site that someone else themed. In the past, there had never really been a best-practice for writing CSS; everyone seemed to have their own opinions on how things should be done and they were ALL different. Bootstrap IS a best practice for writing Less/CSS and HTML.

Display Suite

http://drupal.org/project/ds

Like Features, Display Suite has been around for a while. Display Suite enhances Drupal's core templating engine allowing you to structure the display of node pages(among other things). So you need to display an image in the left column of a page and the body inside the content area? Before Display Suite(and Panels) this may have required some clever CSS wizardry and template overrides. Now it's just a matter of dragging fields into the proper region and clicking save - all of which is exportable using Features.

While it's arguable whether or not Display Suite is superior to Panels, some reasons why LevelTen prefers Display Suite are:

1. It uses Drupal's core templating mechanism and the Field UI, so the learning curve is much smoother than with Panels. In other words, with Display Suite there's really no need to re-learn how to do something the "Display Suite" way.
2. We can render entity displays using Drupal's internal view modes inside of views rather than using views fields. Views fields are messy and require a lot of work to keep consistent. Imagine a site where you have 5 different views all displaying a blog teaser. With views fields(or panels), you would need to update every view to keep them all consistent each time a small change is made. With Display Suite, you can simply edit the blog teaser view mode. When paired with something like Twitter Bootstrap(or not), this is a powerful way of maintaining a high level of consistency across a website, which is an important usability tactic.

Bean (Block Entities Aren't Nodes)

http://drupal.org/project/bean

Content types are to nodes as beans are to blocks. We've all run into situations where you need to display blocks of data formatted a certain way inside the WYSIWYG. Bean solves this problem by allowing you to assign fields to a block type and output using templates rather than using something as free-form as the WYSIWYG. Bean block types are also fully exportable which allows us to include them in our Features.

Source Tree

http://sourcetreeapp.com/

I think we can all agree, Git is complicated even for power users. Trying to manage workflow on a team of two or more is difficult. Git is designed to make this possible without overwriting someone else's work, but some may argue that it actually hinders efficiency and over complicates everything. I know I've caught myself asking "why can't we just go back to the good old days of using FTP?" Still, the positives still outweigh the negatives. On the surface, Source Tree looks like another Git tool for developers. You're right, except that it has this nifty little "Git Flow" button that puts your team into a Git workflow. This workflow allows you all to do your jobs with little interference from anyone else and it's relatively easy (at least in terms of using Git).

See here for a better explanation of what is actually happening. http://nvie.com/posts/a-successful-git-branching-model/

Honorable Mentions

Bakery

http://drupal.org/project/bakery

If you've ever tried to build a really big site with lots of functional components on Drupal, then you probably know how out of hand it can get in terms of trying to QA and fix bugs. Bakery is specifically designed to function as a single-sign-on for multiple Drupal sites (and it does a pretty good job). At LevelTen, we've been tossing around the idea of using it along side a standard multisite setup to "quarantine" large functional sections of a single site, thus creating a sort of "unified multisite". Although this method does present some other challenges(which we're already working on), it should, in theory, lessen the complexity of the different sub-sites enough to make them a lot more manageable.

Entityforms

http://drupal.org/project/entityform

Entityforms is similar to Webform in that they are both designed to solve the same problem. Webform has been around for a long time and has been the defacto standard for creating forms ever since. Unfortunately, it uses its own API and UI for creating fields while Entityforms uses Drupal's core Fields instead and is fully exportable using Features. This simply means that you can use all of the core fields and field type contributed modules to build your form, thus adding another level of consistency and availability of field types.

EVA (Entity Views Attachment)

http://drupal.org/project/eva

EVA is especially cool when paired with Display Suite. Because rather than creating a views block and placing it somewhere inside a region in a page, you can attach it to an entity as a field. This allows you to place the contents of the view using the Field UI.

Pantheon

https://www.getpantheon.com/

I'm including Pantheon in the honorable mentions section because we haven't fully adopted it at LevelTen just yet. However, we've got nothing but good things to say about it, and it's a fantastic efficiency tool for setting up Drupal environments.

Any thoughts? Leave us a comment below!