Customization, which provides users explicit control and the opportunity to specify which elements they want to see on an interface, is a big selling point in software and Web interfaces today. Since the dawn of the Web, with the advent of ASP and PHP, customization has been possible for websites via user accounts and software. There were once severe limits regarding the diversity of customization, frequently put forth by the technology itself, and what was entailed in the act of customizing anything. However, technology eventually surpassed these limits, resulting in a large decrease in limitation of customization with the advent of AJAX, Flash and other Web interfaces that mimic traditional GUI APIs of client-side software. The result of this decrease gave designers the foresight to artificially limit the level of customization, so that any modifications of personal interfaces still conformed to basic shapes and constraints. As a result, when problems arose, things could easily be directed and diagnosed due to predictability above and beyond customization. Programming or tasks oriented around the interface’s shape and conformity could also be expected to work with no real difficulty, because customization was limited to the point of being unable to break this by any measurable level. This was before the explosion of the diversity in platforms and devices in the mid-2000s. Mobile and tablet devices, once mere curiosities, became immediately viable, serious devices for computing and Web interfaces. As a result, new paradigms in design had to be worked out for optimizing Web and software interfaces to match technical limitations, screen real estate and interface style of these touch-heavy devices. A series of interface concepts such as scrollers and dynamic scalers had to be worked out. New protocols to optimize connections had to be invented, and new conventions in Web design wisdom had to be laid out so that the mobile and touch devices could have the accessibility to the internet that had predominantly been PC-centric before. It is unfortunate that this is right around the time that self-imposed limitations on customization for Web interfaces seemed to surreptitiously be lifted. With the prevalence of AJAX and HTML5, it became trendy to let users dynamically reshape their walls and main pages for sites they frequented, customizing elements and actual layouts beyond predictability. It wasn’t long before the cross-bleed between PC and mobile design caused this to make mobile access to an account modified by the PC utterly unusable. The pandemonium that ensued lasted until 2011, when user began and continue to experiment with new measures. Such measures include adding features to customization interfaces that have a user also customize their mobile experience from the PC-end while they reshape their page, to ensure accessibility from their mobile devices without incident. Others include PHP scripts that selectively call for specific elements to render during mobile access, whether PC customization eliminated them or not. A more drastic measure by some has been the redirection to entirely different servers or domains geared for mobile and tablet access that has a crossover with data from the primary source. Of these, the PHP selective load seems to be the most viable solution to full customization with solid mobile access. Customization via mobile and tablet is not going to be a viable solution in the near future, so customization beyond very shallow aesthetics just isn’t important for this side of things, and brings about reduced efficiency and added complexity to accommodate mobile access while the pages are otherwise easy to personalize. This is going to breed many challenges in making the two coexist in the decade to come. One further concern, when it comes to ramifications of extreme customization involves lack of user knowledge in interface design. When users are given completely free reign in modifying the interface to a Web service or personal account, there is a strong chance that their focus in aesthetics will reduce the effectiveness of the platform, thus reducing its usability. This means that for Web usability, this level of customization is going to continue to breed user-instigated poor design, which will hinder tech support and possibly result in misguided poor impressions of a service. Users may not realize they broke it with their abuse of customization. Other users may interact with poorly modified interfaces and get the wrong impression about the Web service or site as well. Aside from going back to enforcing some restrictions based on common sense, this level of customization, by any random user, is going to breed logistical and functional problems for everyone involved. We need to take a step back and consider the possibility that in this case, personalization is the way to go.