1-888-447-9273  |  Email us  |  Contact us

We can help you navigate technical complexity to solve your problems and see your ideas evolve into working solutions. We've been here since 1995, designing and rolling out custom enterprise and web-based solutions across the world.

Technically, we are known for our web services, database, and architecting experience. Our core competencies are PHP, SQL, JavaScript, XML, Apache, and Amazon Web Services. The work we do is more on the engines of websites than the look and feel. From a soft skills perspective, we are known for our communication, commitment to the customer, and our ability to creatively and accurately translate business needs into working software. We also have formal usability training along with usability methods designed into our development processes.

We serve no specific verticals or market segments. As a result, we have partnered with clients in most markets across most business models; example organizations we have focused on: design, ventures and new products, auctions, communications, marketing, sales, housing, dealerships, entertainment, healthcare, professional services, publishing, manufacturing, engineering, retail, education, social endeavors and non-profit offerings, and government-driven initiatives.

Our services include:

• Software Development
• Database Design and Administration
• Systems Analysis and Design
• Interface Design
• Rapid Application Development
• Infrastructure Analysis and Maintenance
• Implementation Rollout and Support, and
• Systems Administration

Here are some examples of how clients get the most value out of working with us: web strategy, programming department overflow, all software development activities, end customer software support activities, RFP creation, RFP replies, architecture inventories and assessments, programming best practices assessment and implementation, mentorship of new programmers, software development training, SEO strategy implementation, finding/recruiting/retaining software development and related talent, business workflow automation and/or systemization, software vendor or related negotiations, and software and architecture project management.

Software Development Services:
We create systems from concepts, perform system conversions and rewrites, help teams make deadlines and overcome technical challenges, and support systems. We have worked with customer teams since 1995 in this capacity. We have become good at what we do because of our focus; we have chosen to only focus on creating and supporting systems using:

• PHP - we've been using this near exclusively as our primary language since 2001
• SQL - we are experts in all facets, having used it since 1997
• JavaScript - we've used this since 2003
• XML - we've used this since 2003
• AJAX (XML and JavaScript) - we’ve used the foundational elements since 2003
• Apache (LAMP stack development) - we've supported servers, clients, custom-built systems, and more since 2001
• Amazon Web Services - we've used this since 2006
• Supporting Web Languages (CSS, HTML, etc) - we've been using most of these since they were created

Our team members' skills are diverse, and we have expert-level knowledge in Java, .NET, and more. However, we don't formally market these services. Our focus is on the technologies listed above. We can help internally or through our network if you need assistance with other languages, but we like this to be an exception, not the norm.

Business Knowledge:

• Our goal is to help you achieve your business goals, and this goes beyond writing good code. We need to understand your concerns, your budget, your timeline, and your other needs. We respect the necessity and understand the value of knowing business concepts and learning the way you run your business so we can support you better.
• We translate business requirements into working systems that add value because we understand the importance of communication, believe in the balance of pragmatism and perfectionism in programming, and take a personal interest in your success.
• Many of our team members read HBR, James Collins, Peter Drucker, Tom Peters, and other works from business leaders and thinkers. The reason why is because we consider ourselves programmers who are business oriented. If the business isn’t solid, the programming is for naught, and we want our programming to do something worthwhile and lasting. We will follow you in the direction you wish to go, but some clients enjoy learning our perspectives, earned from helping many customers over many years and because of our natural interest in business.

Security Knowledge:

• We've worked with highly-sensitive and secure materials, including financial data, healthcare data, and data formally classified as sensitive by the government and vendors who serve the government.
• One of our team members has an active Level 5C Clearance issued by the Department of Justice. This clearance grants him the ability to work on high-dollar and sensitive systems used by the military and the government. The application process is typically over a year for such a designation, and involves an investigation.
• We have formal white hat testing and security experience.
• Several team members have read most of Kevin Mitnick's books, and have helped one customer organization develop its social engineering policies.
• We're comfortable with and expect to sign NDAs before working with you.

Return to top

---

Examples of sites we've developed, and our role in each project:

Please see our Portfolio for screen shots and more in-depth descriptions of what we’ve contributed to.

• http://artsopolis.com - We worked on the back-end administration, link tracking, dynamic event entry, calendar application, RSS feeds, XML output for communication with other sites, artwork voting system, and search refinements.
• http://voices.com - We worked on the user interface design (not graphics, but the processes for visitors to use the site), database design, administration section, shopping cart, member sign-up, partner API, and the communication system (internal email combines with external email). Also, the job process for this client is extremely complex, allowing for milestones by job, deposits tied to the milestones, releasing funds by milestone, managing the agreement between the parties in the job, maintaining the data files, and attributing the file to the right step in the process. Other features of the site developed include a profile section, feedback section, and search functionality.
• http://portagehealth.org - Using a full-featured back-end framework we built, we implemented their entire website while working with their graphics and communications experts for content. Features include a glossary that allows for mouse-hover definitions for keywords in content, café-menu management systems, easy-to-update homepage image rotators, content management systems that users manage based on role-enforced authorization, newsletter management, job application and resume management for job seekers, and an intranet site similar to iGoogle with drag-and-drop widget management that can be accessed by users existing in the company Active Directory listing, which also manages the security for the widgets and other pages.
• http://remedylife.com - We helped the customer rewrite an existing affiliate management and tracking application that feeds visitors into the website. The system can be configured with different campaigns. Information about the visitor and their medical situation is collected by the system. The system then configures itself to display offerings that best match up with what could benefit the visitor the most, while maximizing the revenue yield by Remedylife. The main purpose of the rewrite was to incorporate this new revenue-based sorting and calculation module, and to also standardize the workflow page structure to make it quicker and easier to build out workflows through the database admin.
• GS Engineering - They use our product to manage all their projects, track all billable time, manage payroll, and more.
• Little Caesar's Amateur Hockey League - We developed a website using Perl to manage their teams, statistics, and scheduling. This is the largest amateur hockey league in the world.
• Physicians Insight (private, internal system) - We modeled the business’ workflow into a web-based application. It’s a scalable solution that allows them to manage thermographer data uploads, perform interpretation service management, and have director-level overview of the process. It allows their user base to track and handle follow-up visits, which is a large part of a thermographer’s income source. There are a number of time-saving operations to speed up data entry and definition work by the thermographers and interpreters.
• Horizon (private, internal system) - We worked on the update of the question/answer system, which is where the teachers/professors are able to enter questions and answers. Horizon uses the answers from students to perform academic metrics on the group of students, the quality of the question, and the quality of the answers. The testing process permits groups of questions to be managed together, by category and by academic level.

Most of our work is the programming on Intranet sites or administrative features of public websites. Before there were other good frameworks out there, we created a framework that has all the features as described in the PDF document titled, Up and Running -- Complete Listing of UAR ABLE System Features.pdf . This framework supports over 30 customer websites currently, and is our largest effort to date, including over 18,000 man hours of work. It handles administrative operations, provides database transparency, manages data relationships, administers user management, and facilitates code reuse. We no longer recommend our framework for use today for anything other than very custom solutions that wouldn’t benefit from using community-driven frameworks. We remain quite happy with the strong frameworks and platforms supported by excellent communities, and recommend these to our clients.

We'd like to mention once again that most of our work is done on the engines of websites, not the look and feel. Thus, our accomplishments are hard or impossible to see by just looking at the front-ends of these websites. Given that, we'd be happy to demo the inner workings of our systems at any time pending customer approval. Please note that not all customer work may be shown because of NDA agreements we've signed.

Return to top

---

Here are some PHP and JavaScript code samples. If you’d like more samples of these, samples of different languages, or samples to demonstrate our ability to program in particular ways or for different applications, we hope you’ll please let us know by requesting them. Here's how to contact us.

PHP Code Samples:

• account.php ( source code - text file )
  This is a data model class that holds information on a project or charge account.
• conditionbase.php ( source code - text file )
  This is an abstract base class for the condition component of an alert. An actual test extends this, and provides the data that the base methods run against.
• entityrelationship.php ( source code - text file )
  This provides a generic association model for any two entities in one of the systems we developed. An example usage is associating a person/contact record to a system user record or an address record.
• file.php ( source code - text file )
  This is a file abstraction that represents a file on the file system. It provides convenient methods for accessing various properties, and can tie into other parts of the framework.
• followup-datasource.php ( source code - text file )
  This class provides methods for retrieving follow-up data and persisting it to a database that's configured through the ADODB abstraction layer. It conforms to an interface that the follow-up model and follow-up list models look for in their datasources.
• followup-model.php ( source code - text file )
  This is a primary object model of the system. It provides properties to hold data about a follow-up and any methods that describe actions about the follow-up. A datasource that implements the follow-up interface can be set to the model for persistence handling. This datasource (please see "followup-datasource.php") could be tied to a database, an RSS feed, another application, a SOAP interface, etc.
• maphandler.php ( source code - text file )
  This is an entire class that interfaces with the GoogleMaps generator. This class will automatically locate the required GoogleMaps API key from configuration. For functionality, it can take one or multiple addresses for map plotting via the AddAddress() command. One only needs to submit a textual address or an array of textual addresses, and GoogleMaps will automatically Geocode and process those addresses. Various functions exist to change the aesthetics of the map itself. For example, height, width, icon color and style, and zoom controls can all be changed via their corresponding methods; as an example, SetHeight(400) would draw the map at 400 pixels high. When all the configuration and display values have been set, one only needs to call the RetrieveMap() method to place the map wherever they need it. (Note: The actual generation of the map occurs in JavaScript and in another MapGenerator class.)
• objectparser.php ( source code - text file )
  This is a recursive parsing routine that uses reflection to analyze an object to generate a list of values from that object that can then be indexed through a search engine.
• ordermodel.php ( source code - text file )
  Written for a Zend implementation, this class serves as an interface between an application's business logic and the database table used for storing Orders. It performs SQL queries against a MySQL database to fetch data as the application needs it. More generic methods for saving, deleting, and updating data have been abstracted to a parent class that is shared by all of the system's models.
• persongroup.php ( source code - text file )
  This is a sample datasource used to abstract out data persistence of the data model layer. It handles all SQL queries for this type of entity.
• processfollowup.php ( source code - text file )
  This is a sample command in the command controller system for processing follow-up data from some form of HTTP GET/POST submission. This is usually the last stage in data processing, after validation and taint testing commands have cleaned up the data.
• single.php ( source code - text file )
  This is a component called a displayer that accepts a particular model, and then displays it in some way. The models are assembled by the controller component of the framework, and then the displayer is specified within the view. The result is then hooked into a certain point in a website's template.

JavaScript Code Samples:

• admincalendar.js ( source code - text file )
  This JavaScript class drives an admin interface for a calendar. Most of the calendar is dynamic and operates through JavaScript, and this file manages those operations. The logic makes use of Prototype and Script.aculo.us.
• notifications.js and showonload.js ( source code - text files: notifications.js.txt or showonload.js.txt )
  These are used to drive a simple message handling system. The HTML layout in which these are used will have a hidden DIV tag with an ID of status. The DIV is designed so that PHP writes its messages there, and then loads the showonload.js file if there are messages to display, which causes the layer to flash nicely after the page is finished loading. Once the page is loaded, JavaScript can also write to the DIV for any need. This system uses Prototype and Script.aculo.us.
• payment_sources.js ( source code - text file )
  This contains JavaScript code designed to handle the front of the page where the user enters new payment sources. In particular, it contains methods for validating credit cards using a mod-10 check and regular expressions (regex). It also contains methods that interface with the modular payment processing system to dynamically load and submit payment source forms via AJAX. This uses jQuery.
• protopopup.js ( source code - text file )
  This JavaScript class allows for the creation of a flexible popup layer for showing additional information on any element or action in any project. The setup is easy: you define the ID of an element that triggers the popup, the source of the popup's content, which can be an ID of an element or a URL that is fetched by AJAX, and an options hash for additional settings. It makes use of Prototype and Script.aculo.us for various opening and closing effects.
• selectaddress.js ( source code - text file )
  Displays the dialog box for entering an address. It handles several dialog boxes on the site interface. This uses jQuery.

More samples, walkthroughs of code, and demonstrations can be provided at any time. Here's how to contact us.

Return to top

---

• PHP 4/5.x
  • We've been using PHP since 2001, and it's our primary language. We can support any LAMP-stack development effort.
  • OOP: most of the code we write is object oriented with a focus on reusability and resiliency to change. When we decide not to write OO code, it's for a specific reason.
  • Here are the patterns we apply in PHP regularly: Strategy Pattern, Factory Pattern, Singleton Pattern, Command Pattern, Decorator Pattern, Template Pattern, Adapter Pattern, Iterator Pattern, State Pattern, Observer Pattern, MVC Pattern, Skinny Controller/Fat Model Pattern, and Inversion of Control Pattern.
  • Here's some design principles we apply in PHP regularly: Encapsulate what changes, DRY principle, Program to interfaces and not implementations, Open for extension but closed for modification, and Focus on loose coupling.
  • Libraries commonly used: Apache, Bzip2, cURL, FTP, GD Graphics Library, IMAP, LDAP, Mcrypt, Mhash, MySQL, OpenSSL, PayFlow Pro, PDF, PostgreSQL, Pspell, Regular expressions, SMTP, SimpleXML, XML, and ZIP.
  • Pear: We've used several packages from it, including the debug framework, phpUnit, and phpDocumentor. We also use the class naming structure that the PEAR libraries follow.
  • Other experience: IMagick and memcache
  • Please see the previous work section or our portfolio for project examples. Up and Running focuses exclusively on PHP, SQL, JavaScript, and XML so nearly all of our software development is PHP-based.

• Databases and SQL
  • Two of our core strengths are database design and database management.
  • We currently manage 100's of different databases in MySQL/PostgreSQL for different purposes.
  • We have been using databases and SQL since 1997.
  • We're able to take a concept; design the database formally using Entity Relationship Diagrams, Data Dictionaries, and other supporting modeling conventions as needed; and implement the database.
  • We're well versed in using existing databases, whether it is simple usage, extension, improvement for faster and safer performance, upgrades, conversions, API development, or other aspects of database usage and maintenance.
  • We have extensive experience writing SQL, and know nearly every nuance of the SQL 99 standard (basic queries, types of joins, utilizing sub queries, views, temp tables, transactional processing, etc.), including a number of proprietary features.
  • Though the majority of our experience is with MySQL and PostgreSQL, we have experience with these as well: Oracle, SQL Server, Informix, DB2, FileMaker, Caché, Access, and FoxPro.
  • We've led multiple migrations from previous database systems to new ones.
  • We've helped people optimize their databases. For more information, please see our performance and scalability section of this team resume.
  • We've modified existing open source databases to perform better by adding or extending features.
  • We've created systems with shared database access among different applications, running on different platforms.
  • We are well versed in advanced database operations, such as transition management, triggers, views, complicated queries, and stored procedures.
  • We've also used a number of abstraction layers for database communication, including ADO, ADOdb (PHP), DB (PHP), and NpgSQL (more of a driver than abstraction). Features utilized in these layers on past projects include: stored procedure execution, caching and performance enhancers, record set selectors, and performance monitoring.
  • Most of our applications that involve a database are built with a datasource layer between the main system objects and the actual SQL queries that manipulate the database, accomplished using the Domain Object Model and the Data Mapper pattern. We've also written applications that use the Active Record pattern.
  • SQL
    • In all of our programming work, we've used SQL for database operations.
    • We've written queries for accessing data directly and routines that assemble SQL on the fly.
    • We've worked with existing SQL statements, both using them as is, and optimizing them if needed. Clients have had us assess the slowest parts of their site(s), and in most cases we’re able to make bottleneck operations perform faster by multiples. (We helped a recent client get 90x faster.)

• JavaScript/AJAX
  • We've used JavaScript in nearly all of our web-based applications.
  • We use Prototype, jQuery, Mootools, Ext JS, YUI, Dojo, and Script.aculo.us regularly.
  • We've used AJAX to create two iGoogle-like applications. One is used for an Intranet application that allows people based on their credentials, driven by our system’s communication with Microsoft’s Active Directory, to add various modules to display data and access tools (widgets) relevant to their position within the organization. Another one is used by administrators to update the content they display on their websites. By simply moving modules using JavaScript, they can change the look and feel of all the websites they maintain with the administrative features.
  • We use XML to support configuration settings and AJAX output on various web applications.
  • We wrote extended and custom JavaScript objects to accomplish a particularly-difficult set of functionality that wouldn't be handled well by older client/server cycles.
  • We know how to use XML and JSON for AJAX requests.
  • We've built shopping cart-style systems out of AJAX.

• XML
  • We know XML, and can deploy it for whatever need you may have.
  • For one of our clients, XML served as a storage mechanism for quality data. XLST allowed for various presentations of that data on the Intranet.
  • We have designed and deployed SOAP interfaces.
  • We have used DTD's to generate custom API's.
  • We can syndicate any content for use in mashups, portal pages, RSS readers, and more.
  • Please see our Interfaces section of this team resume for more information about our XML experience.

• XHTML/CSS
  • We've been using these since they were created, and our preferred editor is a text one, meaning we prefer to hand code our XHTML and CSS as it produces cleaner code.
  • Our work is compatible with the major browsers, whether they support W3C compliancy or not.
  • We are familiar with SEO Semantic coding and markup, and understand the importance of writing our code in this manner.
  • We generally design and write XHTML or DIV style layouts for sites, utilizing CSS for markup. Our team can work with the older table layout method as well.
  • We've worked with templating engines before, and wrote one for the UAR ABLE framework as well, which integrates into a custom CMS system.  We can use any templating system you wish to if you prefer to use one.
  • Graphics designers often have us take their works of art and skill, and convert them into web-ready CSS and XHTML.
  • We’re confident we can use XHTML and CSS to do anything you need.
  • Please see our Experience in using and interpreting web standards (browsers, accessibility, and validity) section for more relevant experience in this area.

• Amazon Web Services (AWS) and Management
  • As its one of our core competencies, we’re able to help with any Amazon Web Services need you may have. The following are some examples:
  • Amazon Simple Storage Service (S3):
    • We’ve implemented S3 for all of our internal systems; development, testing, and production servers; as well as for many of our clients. One client is one of the largest SEO internet marketing firms in the market.
    • For one implementation, a wrapper script was written to provide an abstraction layer for the rest of the client code. In this manner, if the API signature changes on S3's side, then we just have to change the internal implementation of the wrapper. Also, additional business logic in how S3 is utilized can be contained in the wrapper or injected at runtime to help govern operations.
    • Up and Running and many of our clients have moved to S3 to reduce bandwidth consumption/needs on our servers, along with the administrative oversight and costs that need to occur for internal servers.
    • Another benefit for many clients is that the S3 service serves up files quickly, usually much faster than internal servers. We find this particularly useful when a feed system is hosted on other websites. The images that make up the feed graphics can be put on S3 to save bandwidth and reduce the cost of transmission. These feeds could be viewed 10,000’s of times in an hour, and would put a considerable load on the clients' dedicated hardware. Thus, in this example, S3 really saves money and results in a better user experience.
  • Amazon Elastic Compute Cloud (EC2):
    • We’ve created machine images to manage Up and Running’s critical services and developer resources.
    • We wrote a Perl script, utilizing the instance control API, to dynamically mount EBS volumes and attached Elastic IPs in an instance during startup using the user data scripting system. This script allows for a machine instance to be configured in such a way that configuration and user data is persisted between reboots. The mounting overlays critical areas of the operating system so that configuration changes and user data are stored on the EBS volume, making the running instance work more like a dedicated server.
    • We utilized the elastic IP system to assign a public IP to the instance, and configure a round robin load balanced system when load dictates it.
    • We use EBS snapshots to handle backups of EBS data, along with an rsync-based offsite backup system to protect all server data.
  • Amazon SimpleDB:
    • We’ve explored, and tested this.
    • We’ve presented this to clients, and they have not chosen to go with this solution at this time.
  • Amazon Mechanical Turk:
    • We explored the implementation of this for a customer who needed some manual assistance in a workflow with some specifically-defined tasks.
    • The API makes it easy to integrate these features into a system such that human-provided work can be submitted into the principle application.
  • Other Amazon Web Services: with the experience we have using Amazon’s Web Services, we’re confident in our abilities to quickly use any of their other or future services.

• Perl
  • For a customer, the largest amateur hockey league in the world, we wrote a team management system that ran a 900+ team hockey league that had over 10,000 user accounts.
  • We currently use Perl for maintenance tasks and one-liners in command line chained commands.
  • We wrote a Perl script to handle dynamically mounting EBS volumes in an instance during startup, using a user data scripting system.

• C#
  • We’ve created enterprise systems in C#. Though we can help clients with this need, it’s not our core focus.
  • We've used C# to write an online backup tool.
  • We also used this to write a client-based application to work with our web-based framework for entering time easily.

• Java
  • We’ve written enterprise Java code. Though we can help clients with this need, it’s not our core focus.
  • We’ve applied a lot of the patterns perfected in the Java world in the PHP world.
  • We have experience with platform independence written in pure Java, Java Server Faces (JSF), Enterprise Java Bean (EJB), Java Application Servers like JBoss, and much more.

• Ruby
  • We’ve written Ruby code for production websites. Though we can help clients with this need, it’s not our core focus.
  • We've worked in existing Ruby engines to modify complex systems to operate more expansively and improve the efficiency of the engine.
  • We've written entire engines for real-time user interactive systems that deal with simple user input being translated into complex actions and basic system artificial intelligence (AI) designed to react to said input.
  • We've been working with Ruby extensively since 2006, and still actively use the language for everything from AI to user interface design to graphics and animation.

• Interfaces
  • We know the methods with which applications can talk, and the abstract pros/cons of each approach. We’ve worked with and written numerous APIs, interfaces, and code to make different tools work together well.
  • We can configure any SOAP or REST interface needed to make a system work with other systems, or design and deploy a specific, custom API for interaction with a third-party application.
  • For social networking purposes, we've done some interesting work:
    • Twitter: we've created a Drupal block for a social media portal site that uses the Twitter API to display a list of the most recent tweets on a given Twitter account. The block can be configured via the Drupal Admin Panel, and allows the website owner to enter their Twitter account details and configure several parameters regarding the display of the tweets. Additionally, we have created a Drupal module that hooks into Drupal's existing blog system, allowing the user to post an announcement to twitter automatically when they create a new blog post. The module adds a new checkbox option to the page for creating blog entries, and, if checked, will use Twitter's API to publish a new tweet for that blog post.
    • Facebook: the social media portal site we created is integrated with Facebook Connect for user authentication and comment-posting purposes. For user authentication, this allows a visitor to log into the site using their Facebook username and password, and does not require them to register a separate account on the social media portal. Existing Drupal users can also authenticate via Facebook Connect to take advantage of the comment-posting integration. When a user posts a new comment, they have the option of automatically publishing information about that comment back to their Facebook account. Additionally, we have integrated Facebook with Drupal's blog system in the same way that Twitter is integrated with it. When a new blog post is created, the user has the option of automatically publishing information about that post back to their Facebook account.
    • MySpace: a MySpace option can be presented on Drupal's blog posting form as well in the system we created, giving the user the option of automatically publishing new blog posts to both of those services.
    • Reddit: we have explored integration methods for this service.
    • Digg: we have explored integration methods for this service.
    • RSS Feeds: in addition to sending information out to social sites, the social media portal can also receive information from any site in the form of an RSS feed. The Blog owner has the ability to monitor RSS feeds from within the Drupal admin panel, and can choose to post any story from the feed into their own blog (with additional comments of their own on the story contents).
  • We have explored Yahoo! Query Language (YQL): "The Yahoo! Query Language is an expressive SQL-like language that lets you query, filter, and join data across Web services." (Source: http://developer.yahoo.com/yql/ )
  • We have used Authorize.net's Advanced Integration Method (AIM) to allow a proprietary e-commerce site to accept credit cards using Authorize.net, while still retaining their existing order-handling business logic. Credit card information was collected from the user on the merchant's site, and securely transmitted to Authorize.net using cURL. The site also took advantage of Authorize.net's ability to store extended order information by transmitting order details and complete customer billing and shipping information with the credit card information. The response from Authorize.net was then processed by the script, and the proper code was executed depending on whether the charge was successful or not.
  • We have customers who have us attend API design meetings to act as consultants for them and for the third-party team of programmers they meet with for such discussions.
  • We wrote a REST API handler and several plugins for a WordPress implementation for a site that consistently remains in the top 100 Alexa-ranked sites in the United States.
  • Examples of interfaces we've worked with:
    • Google APIs
    • Twitter API
    • Facebook Connect
    • MySpace API
    • Authorize.net
    • PayPal's interfaces
    • Various shopping carts
    • VeriSign's Payflow Pro API
    • Intuit's QuickBooks Interface
    • UPS WorldShip
    • USPS APIs

• ORM Experience: We will demonstrate our knowledge of this advanced pattern by describing how it works and how we've used it:
  • This is a technique that allows the translation between relational data structures and object data structures. Generally, you see this used when you have an object model system that defines your domain knowledge and you're storing the persistent data in a relational database. The two don't always map correctly so this layer provides translation.
  • There are a number of packages that can do a lot of this automatically for you through some basic configuration, but the most complete solution is usually achieved by writing a custom ORM system for the specific domain problem faced.
  • We've written a custom ORM between the UAR ABLE framework's model system and the datasources that track and query persistent data.

• MVC Experience: We will demonstrate our knowledge of this advanced pattern by describing how it works and how we've used it:
  • This is a pattern for developing applications that makes use of reusable UI interfaces and object models. The controller glues the view and the model together by defining what parts of the model show up in the view. The view takes input, which goes through the controller for translation to the model.
  • The model can then update the view through an observer pattern.
  • We've used a variant of this (Model 2) in the UAR ABLE framework. The controller defines the combination of functionality that takes place for a page and feeds the view the necessary models that are needed to make it display. We've also started developing more of a standard MVC pattern in the UAR ABLE framework, using JavaScript and the Prototype library to provide real-time updates on the client-side page.
  • We’ve used many frameworks that use this pattern, including CakePHP, CodeIgniter, Kohana, Symfony, Zend, and more.

• CakePHP: open source, PHP Framework
  • We used a built-in active record system to construct order management and fulfillment processes.
  • We integrated MooTools ("a super lightweight Web 2.0 JavaScript framework") into the framework.
  • We developed a small, rich text controls helper, providing autocomplete and date picker functionality.

• CodeIgniter: open source, PHP Framework
  • We added CMS functionality and a drag-and-drop layout system within an application that uses CodeIgniter.
  • We wrote an ActiveRecord base object that supports the pattern better than the built-in active record system.
  • We developed a custom shopping cart using AJAX on top of this platform.
  • We created authentication, SOAP transaction, newsletter, mailer, and message tracking system modules.
  • We extended the core application model to integrate an application with a FileMaker database system.
  • We created a system by which a single instance of a core set of libraries, models helpers, etc. is shared between multiple websites.
  • We created a reusable and configurable application to handle sealed bid auctions.
  • For a major international brewing company, we used CodeIgniter to handle most of the page logic and presentation organization. Specifically, we used the FX.php library to connect CodeIgniter to the backend database, where most of the data for the site is stored. We used a dynamic FTP system to create temporary accounts on the fly for a more robust upload system that can handle files multiple gigabytes in size. We used a legacy database, a hard project requirement, to drive the system, which made it more of a challenging project.
  • For the largest wholesale baker of cakes in the US, we used CodeIgniter to handle their specific business rule and presentation needs.

• Kohana: open source, PHP Framework
  • This framework, originally based on CodeIgniter, is a very clean PHP MVC Framework.
  • Benefits of using Kohana:
    • Kohana has a secure, extendible structure that enables easy development for multiple websites driven from the same platform. We’ve used this architecture to support clients such as Artsopolis.
    • This framework has a modular system that easily accepts new and useful addons.
    • Kohana has a collection of helpers and libraries for the most common operations, which speeds up development time.
    • The helper classes are automatically loaded by the framework so it’s easy to use them in controllers, models, libraries, or views.
    • Kohana has an active community that has and continues to make contributions of code and information.
  • Some examples of how we’ve used this framework:
    • For one client, the Gmaps module was used for quick and easy implementation of the Google Maps API to generate page detail information.
    • We implemented the pagination helper quickly and easily for one of our clients.
    • CAPTCHA is easy to use, and was updated to allow multiple domain use from a single source.
    • We’ve implemented the authorization module of Kohana for most of our customers that use this framework. It’s been well received, and has resulted in saved time and money in the software development projects where employed.
    • The Template controller addon was expanded and improved to provide a flexible Template system useful for different sites of the same network (the same codebase drives many sites across the world in a SaaS setup).

• Symfony: open source, PHP Framework
  • We know the Symfony MVC structure.
  • We have experience with third-party abstraction layers included in the Symfony framework, such as the "Criteria" and the "Propel" abstraction layers. Criteria uses parameters to create an SQL query, and Propel uses raw SQL queries instead for more complex or specific queries.
  • We've used Prototype, jQuery, and script.aculo.us, the JavaScript frameworks/libraries included with Symfony, for uses that range from simple to advanced.
  • We've integrated PHP and C++ document conversion libraries with Symfony to allow multiple types of documents to be combined into a single PDF download.

• Zend: open source, PHP Framework
  • A major project we were involved with used Zend to connect one customer with all of its customers so it could provide value-added services to them automatically. The system was developed so it could be applied to other sectors the primary customer serves with no retooling.
  • We used Zend to create a delivery management system, including the front-end customer interface and a fully-functional back-end system for managing the business logic.
  • We used components, including Zend_Forms; the Zend database tables ORM layer; and custom-written functional classes, for the model interaction.
  • We tied in jQuery to provide rich, AJAX-driven features on the front-end side.
  • Using a combination of jQuery and Zend, we created a robust geomatic services module to validate and geocode addresses in a restaurant delivery management system.
  • We programmed a full-featured shopping cart system with support for multiple tax zones, special tax exemptions, dynamically-determined fees, digital and physical goods, and the ability to have multiple people participate in an order. All of these features integrated with Zend's database, controller, and view layers.
  • We programmed a complex, dynamic fee system that allowed an administrator to specify rules that determined whether a particular fee, which could be either a flat fee or a percentage of the total order, would apply to a particular order. The rules could be based on the delivery location, the total order cost, the total number of items in the order, the item vendor, the location of the item vendor, the type of order, and the estimated time of delivery of the order. The system made use of Zend's automatic class loader to allow rapid development of the rules using a modular system.
  • The shopping cart system allowed multiple users to add items to a single order, and allowed multiple users to pay for a single order. The master user was able to control how much the other users could spend, and was able to grant stipends to those users.
  • We programmed an interface to validate a user's address by confirming the details of their address using MelissaData address verification and validation services.
  • We used Google Maps mapping functionality to "show" the address the user was plotting, and display related restaurants close to their location.
  • We programmed "radius" functionality that allows a user to define a certain search radius using their originating address as the center point. The Haversine formula was used to calculate a "zone" over a spherical area (the Earth) that corresponds to the radius designated by the user.

• Content Management Systems (CMS’)
  • We've used several open source CMS packages and frameworks, and have extended them using custom code. Examples: Drupal, Joomla!, WordPress, and ExpressionEngine.
  • When we first started using PHP, we developed our own CMS within a framework that supports many features beyond strictly CMS features. The CMS we developed handled dynamic page and navigation creation, along with version-controlled content. We could create inline editing features as needed. We no longer recommend this to clients because of the rich CMS solutions backed by strong development communities that exist today.
  • We've done CMS conversions, both from static sites and CMS-driven sites.
  • We've helped companies define custom CMS operational oversight processes for their enterprises.

• Drupal: open source, PHP content management system and more
  • We have worked on Drupal since version 4, with the majority of our time being spent on Drupal 5 and Drupal 6.
  • We’ve done conversions to Drupal 6 from Drupal 5 and from non-Drupal sites.
  • We've handled lead development duties for a production site with 8,000+ registered users and another site that had 20,000+ page views per month.
  • We can implement any theme, implement any module, design custom modules, extend existing themes and modules, perform Drupal conversions, and lead any other Drupal need you might have.
  • One week in 2009, we had three companies independently asked us to finish what other development teams had started. We understand Drupal, but our core competencies, including a deep understanding of PHP and SQL, are what allowed us to contribute to these projects. We helped our customers achieve their goals with Drupal because we knew the foundational aspects of programming, specifically PHP and SQL, at the expert level.
  • Here are some of things we do and have done with Drupal:
    • Maintain databases from development to staging to production using a custom script written in XML and PHP.
    • Programmed internationalization implementations, including Japanese and Spanish.
    • Integrated the Yahoo! Grids CSS system to work as a Drupal theme, fully customizable within the constraints of the grid system. This reduced the time and effort required to develop themes.
    • Prepared ad campaigns for monetizing site usage, and implemented them using JavaScript functionality.
    • Themes; here is some of the work we’ve done with themes:
      • We can implement new themes based off of new designs to the pixel-perfect level. We know this because we work with customers who are professional designers with excellent eyes for perfection in design.
      • We've created custom themes for Drupal websites using template files, CSS, HTML, and JavaScript. Our approach enables almost every view within a site to be customizable.
    • Standard Implementations:
      • We implemented user-oriented functionality based on Drupal's core functionality. Examples include: User Roles, Remember Me, Tracker Module, and more. Remember Me allows users to be remembered every time they log in. The Tracker module allows tracking of a user’s posts and actions within the site.
      • CCK (Content Creation Kit) is core Drupal functionality we commonly use to allow administrators to define custom node types. We use CCK to help users not experienced in writing PHP/MySQL to have an interface for adding content to their sites.
      • Implemented the FlashVideo module, which allows for uploading video to nodes in Drupal. The video is converted to .swf, and has built-in interfaces for the Dash Media Player and server support for hosting videos using Amazon's S3 servers.
      • We have used the blocks interface to enable an administrator to define blocks of content to be shown in specific areas of pages within a site.
    • We have written over 50 custom modules for Drupal, and here are some examples of those:
      • Actionable Events Module - creates a reporting system similar to what is implemented in Facebook that updates the owner of content when actions are taken on that content. For example, if a user posts a blog and a comment is posted on that blog, the owner will be alerted on their profile page.
      • Anonymous Posting Module - uses Drupal hooks and allows authenticated users to post content anonymously. Records user id for the administrator to view, but for other users the content will appear to be posted by anonymous.
      • Ask Module - extends the forum module to allow users to ask questions of a specific group. Uses the taxonomy categories as the forum containers.
      • Comment Alter Module - extends Drupal's default commenting scheme to alter just about anything needed. It adds the Nofollow tag to all comments posted by untrustworthy users. It also spell-checks posts by users.
      • Comment Rating Module - extends the votingapi module to allow voting on comments before this functionality was offered in the fivestar module.
      • Community Site Content Creation Module - allows users to easily add products, add websites, save favorite websites, ask group questions, ask individual questions, add a book to the site, and more.
      • Limit Tags Module - hooks into the taxonomy functions, and limits the freetags a user is allowed to enter based on a predefined set of taxonomy tags. Has an autocomplete function available for users, and also suggests possible terms.
      • Location Privacy Module - alters the behavior of the location module by storing user input in the database. A user can set their location to be viewable by no one, by other users marked as friends (extends the buddylist module, a contributed Drupal module), or viewable as a public listing.
      • News Feed Module - mimics Facebook's news feed function in that it reports to users what their friends are doing on the site. Reports comments, posts, and questions, and can be extended to update on other programmed actions. It can be digested as an RSS feed.
      • Node Book Module - custom node type module that allows for users to enter a book that they like. Specifically, it allows a user to enter a title, price, ISBN, and scrapes an image from Amazon.com to use as a descriptive image of the node.
      • Node Generic Module - custom node type module that supports users' input of websites they prefer. Allows a user to enter a title, URL, and description of a website, and then attempts to scrape an applicable image from the site to use as the node's image.
      • Node Privacy Module - this module allows a node to be marked as private, public, or viewable only by friends of the owner (extends the buddylist module, a contributed Drupal module).
      • Node Question Module - custom node type module that mimics Yahoo!'s Answer's functionality. Questions are asked by users, and are then answered by experts on the topic. Other users of the site can comment or rate (using fivestar module, a contributed Drupal module) the answer and question.
      • Privatemsg Connections Module - extends the privatemsg module to enable interaction with the buddylist module. This functionality allows a user to send private messages to other users who they have added as friends.
      • Profiles Module - extends Drupal's default profile functionality by creating sub-navigation for the profile pages, adding extra functionality for message boards (using the guest book module), and creating customized searches that allow users to find others with similar interests.
      • Questionrouter Module - extends the Node Question node type in that it sorts through the available experts on a site, and then tries to route a question to the proper expert. It performs the routing by comparing the taxonomy tags a question has with the self-defined expertise associated with the users.
      • Questions and Answers Module - a module that mimics Yahoo! Answers. A user can ask a question that remains unpublished until an expert answers the question. Once answered, both are published to the community.
      • SOAP Digest & Search Module - the module, connected to a web services API, uses SOAP to download the results, and display them in the Drupal site. AJAX was used to retrieve data from the server asynchronously.
      • Taxonomy Module - extends the taxonomy term functionality to create groups based on terms. It provides a means to tag users and content, and allows users to add a taxonomy tag to their profile and view all content tagged with this term as part of a news feed grouping. The news feed was a custom module we developed. Its features were similar to a Facebook news feed, where a user who is part of a group can see all actions that occurred within that group. We also implemented tag clouds using the taxonomy module.
      • Taxonomy Wikipedia Module - custom module that grabs definitions for taxonomy terms from Wikipedia. The definitions as well as pictures are then displayed within the homepage for that taxonomy term.
      • User Tracking Module - a custom module that enables one user to track the activities of another user within a site. As an example, this permits a user to easily view all the content another user has created, and subscribe to an RSS feed of that activity.
      • Various Utilities Module - handles everything from homeless hook_form_alter functions to styling search pages, profiles, forms, and blocks.
      • Violater Actions Module - extends the flagged content module to allow an admin to block a user, delete content, unpublish comment, and send warning emails to troublesome users.
      • Wikipedia Definition Module - attempts to add a definition based on Wikipedia content for each taxonomy category added on the site. Scrapes the content from Wikipedia, parses it, and displays it.
    • In addition, we have used, modified, and/or updated the following contributed or core Drupal modules in a heavy-traffic, production environment:
      • Aggregator - publishes syndicated content using RSS.
      • Amazontools - allows a user to input an ISBN or book title, and subsequently fetches information for that book from Amazon.com.
      • Block - allows an admin to add content to different areas of the page (blocks) whenever they desire. Can add new content by administering the blocks.
      • Blog - builds the blog node type.
      • Blogapi - extends the blog node type to allow for customizations.
      • Buddylist - allows users to create lists of friends.
      • Captcha - builds support for adding captchas to forms.
      • Color - allows the administrator to change the color palette of a theme through the admin panel.
      • Comment - builds support for the commenting functionality.
      • Contact - builds functionality for creating a contact form to allow site visitors to contact the administrators.
      • Devel - assists in developing, clearing caches, and updating content.
      • Favorite_nodes - allows users to designate favorite items on Drupal sites.
      • Fckeditor - adds support for the fckeditor, a popular WYSIWYG editor.
      • Filter - allows for filtering of content. Can write custom filters to parse content, remove harmful text (code), and remove offensive words.
      • Fivestar - extends the voting module to allow for a fivestar voting widget using AJAX.
      • Flag_content - allows users to flag offensive content for future review.
      • Forum - creates the forum node type.
      • Guestbook - builds support for a Facebook-style 'wall'.
      • Help - creates help topics and text.
      • HOF - a hall of fame module that builds publicly-viewable statistics to give credit to users who cause a site to succeed.
      • Invite - builds a form that allows a user to invite their friends via email.
      • Karma - allows for a comment rating system based on a user’s past comments. If a user has a good rating on previous comments, they are considered a trusted user.
      • Legacy - remaps deprecated style URLs to URLs usable by Drupal.
      • Locale - allows for multi-language support.
      • Location - allows users to input their location at the zip code or full-address levels.
      • Logintoboggan - allows the administrator to set the destination page after a user logs in.
      • Menu - builds support for the menu functions in Drupal.
      • Node - creates support for nodes: adding, editing, moderating, deleting, searching, etc.
      • Nodewords - a toned-down version of the taxonomy module that allows for meta tags on nodes.
      • Path - builds support for creating readable URLs for pages normally labeled like /taxonomy/term/12/15.
      • Pathauto - automatically generates path aliases for nodes.
      • Ping - can be set to notify third-party sites of changes on one’s site.
      • Profile - builds support for the profile functions supplied by Drupal.
      • Poormanscron - runs cron jobs on systems that don't have access to the cron application.
      • Privatemsg - allows users to send private messages to each other.
      • Profile_privacy - allows for users to set privacy on their profiles.
      • Remember_me - uses cookies to remember users.
      • Search - builds support for the Drupal search engine. Currently uses MySQL, but can use Solr.
      • Statistics - creates reports on default Drupal values, and can be modified to add other site-specific stats.
      • System - helps build the infrastructure Drupal is based on.
      • Tagadelic - creates tag clouds with taxonomy terms.
      • Taxonomy - builds tagging features.
      • Taxonomy_super_select - builds a multi-select form for taxonomy terms.
      • Taxonomy_xml - allows input of taxonomy terms using XML. Allows administrators to input a large number of terms.
      • Throttle - allows specific modules to be throttled based on Admin decisions. If a certain module takes too much bandwidth, then this module can be used to only allow it a certain amount of processing power/bandwidth.
      • Token - allows for small bits of text to be entered into documents using placeholders like “%content”, as well as allowing for other modules to create their own custom tokens.
      • Tracker - allows for tracking of users based on what actions they have done on the site. It can track content posts, track comments, and can be modified to track other types of actions.
      • Upload - builds support for uploading files.
      • User - creates support for the user object functions.
      • Userpoints - a points-style module that doles out points based on rules provided by the administrator.
      • Votingapi - builds the backend voting support that is extended by other modules like the fivestar module.
      • Watchdog - handles the logging of errors and other declared actions to track on the site.
      • Workflow_ng - allows customization of Drupal's built-in workflows.
      • Xmlsitemap - creates a sitemap that conforms to the sitemaps.org specification.

• ExpressionEngine: commercial, PHP content management system
  • Created by the same company that created CodeIgniter, a PHP MVC framework that we use heavily, we are quite comfortable using ExpressionEngine.
  • We can extend ExpressionEngine using its Extensions, Plugins, and Modules.
  • Being that it’s a commercial product, this system is well supported and has good documentation. Many open source projects are well supported and have good documentation as well, but many don’t.
  • We’ve used this for standard CMS implementations, as we like the flexibility it affords us.

• Joomla!: open source, PHP content management system
  • We can implement Joomla! as a basic CMS system, or deploy it in a way that produces a full-fledged, richly-featured site. We understand the way it operates, and can use its or the community's extensions, as well as create new ones from scratch.
  • Here are a couple of examples of how we've used this system beyond basic CMS implementations:
    • We've combined the built-in menu and banner modules to provide enhanced navigation options for the client.
    • For a custom scheduling workflow, we provided front-end users of Joomla! the ability to show time of availability during a short period of time (two or three days) to other frontend users. Once logged-in, each front-end user is able to select time of availability from a personal page that shows a simplified personal agenda, as well as see a list of available users from a module published in the portal.

• WordPress: open source, PHP content management system
  • We are able to help you use this system for a simple blogging website, a simple business website, or as a full-fledged, multi-blog business website. Wired, Yahoo!, the US Airforce, TechCrunch, Ben & Jerry's, the Wall Street Journal Magazine, and many other respected and established companies use this system to drive their websites and/or blogs.
  • We can implement any theme, plugin, or customization that's needed. Of course, it'll be easier if we select components that work well together from the start, but we can write new functionality to replicate or extend any features you wish.
  • In terms of process, what we typically do for WordPress sites is start with the overall design. Following that, we decide on the content. Finally, we develop the theme and style sheets to match the design, and structure it around the organization of the content. Lastly, we ensure that the content is easily maintainable and expandable. As we understand what WordPress is doing 'behind the scenes' (we have a deep understanding of the building blocks of WordPress, which are PHP and SQL), we are also able to quickly grasp WordPress' limitations, and look for alternative ways to accomplish a goal versus trying hard to find a plugin that will do the work poorly and in a non-integrated fashion.
  • We think the primary difference between people new to WordPress and ones that are gurus is the use of best practices. Using consistent styling, proper WordPress calls to determine context, and making the site as simple to maintain and update as possible is proper procedure. It is very easy with WordPress to just hack in changes as needed, but as those hacks accumulate, it can make quite a mess. Similarly, a clean separation of layout from appearance in the style sheets is important when creating a theme. For a reusable theme, the two should be entirely separate so the styles can be updated to reflect a new color scheme or design without preventing maintenance updates from being applied to the theme and layout.
  • We understand how to make WordPress sites SEO friendly.
  • We are familiar with WordPress plugins, which allows us to help customers more efficiently by applying already-written plugins, versus creating them from scratch. We also know which plugins to avoid.
  • We think, just like when choosing a project framework, WordPress is a great tool for specific jobs. At the same time, it has been used for many things that it is not good at, which frequently has resulted in migrations to other platforms or full custom site rewrites. We have learned a lot already about what WordPress is good at and what it isn't, and we think that understanding and unbiased perspective is important when planning a project. WordPress is a great blogging platform.
  • We wrote a REST API handler and several plugins for a WordPress implementation for a site that consistently remains in the top 100 Alexa-ranked sites in the United States.

• E-commerce
  • We've worked with open source, hosted, and custom-built shopping carts.
  • We've worked with payment and accounting interfaces.
  • We view e-commerce workflows as a subset of business workflows. There are two components in our opinion related to e-commerce:
    • End-user presentation with calls to actions, generally to purchase or encourage more research internal to the site, and procedures to encourage more spending and loyalty.
    • Back-office operations for allowing more to get done with fewer resources, and, in fact, encouraging and allowing end users to perform as much of these as possible.

• CRE Loaded™: open source, PHP e-commerce system with commercial options
  • We can implement CRE Loaded™, extend it, theme it, and help you use it for any purpose you wish.
  • We have done detailed and extensive theming of CRE Loaded™ for the presentation layer of the system.
  • We've created custom components to pull featured information from CRE Loaded™ for insertion into other parts of the website.

• Magento: open source, PHP e-commerce system
  • Magento - Overview of Some of Our Capabilities
    • We’re able to use Magento to accomplish any e-commerce business operational workflow you might want to accomplish. Examples follow throughout this Magento section of the team resume.
    • We can create one product in Magento to keep inventory for each size and color variation, while making it appear as one product. Using Configurable products with Attributes assigned to Attribute Sets, we can create all the combinations of the product, and then inventory can be managed for each item type (Large Blue T-Shirt vs. Medium Blue T-Shirt, etc.).
    • We have built a Magento site with multiple sites and storefronts tied into the same backend. Magento has this functionality built in; each site can have products from the "main" catalog, etc. The different storefronts or websites can exist with different URLs, security, and checkout methods. They can keep defaults from the parent installation, or use customized settings. They can pull all their attributes from the main site so you manage inventory, products, etc., through a single place, or this can be customized.
    • We can manage upgrades seamlessly by extending Magento using best practices, thereby lowering support costs. We can modify code in a custom area of the code base, never touching or changing anything in the core. In this manner, upgrades are straight forward, and one does not have to support a patch list that needs to be applied each time one upgrades. The approach taken to accomplish this ease of maintenance depends on what the update does. There are ways to add the code to Magento that work outside of the main site so that they don't get affected; for example, to make a new payment type we created a new Payment Method that shows up in the admin page. This new method uses its own controller files, and updates Magento through standard methods. Thus, if Magento was updated, it wouldn't affect the customization at all.
  • Magento Customizations
    • Implemented full-site templates, and performed Magento CMS integration with specialized designs from customers’ designers.
    • Created custom attributes for specialized products, and implemented into template designs.
    • Integrated shopping cart item summaries into the template designs.
    • Integrated security upload features for credit references into sites’ customer accounts.
    • Implemented special shipping rules and alternate shipment address recording for specialty items.
    • Created special export features to share alternate shipping addresses with third parties.
    • Created new Magento payment method module that uses a merchant account API to perform real-time credit card processing.
    • Implemented specialized Purchase Order payment method to allow site customers to request a PO with a custom PO number based on their credit references.
  • Magento Integrations
    • Customer is able to easily manage their online orders in one step with one interface seamlessly integrated with QuickBooks.
    • Integrated Magento with specialized T-HUB software for easy summary order management.
    • Integrated Magento and T-HUB with QuickBooks accounting software for easy automated and manual updating of purchases to create QuickBooks Sales Receipts and customer information.
    • Created custom workflows to allow Magento orders to flow to WorldShip for batch shipment and customer notification.
    • Worked with customers to create workflow for Magento orders to allow shipment through QuickBooks.
    • All Magento design changes were done within the standard Magento template format.
    • All payment methods were created as Magento modules and integrated into Magento in standardized formats.
      

• osCommerce: open source, PHP e-commerce system
  • We can implement osCommerce, extend it, theme it, and help you use it for any purpose you wish.
  • We have done detailed and extensive theming of osCommerce for the presentation layer of the system.
  • We created a shipping module to provide international USPS support.

• E-commerce - related systems, carts, and more:
  • We have used X-cart, Ubercart, Zen Cart, and many other commercial and open source solutions. Though it’s written elsewhere in this resume, we think it useful to mention that we know systems, we know programming, and we’ve helped many companies implement and customize their e-commerce implementations. We can help you with any e-commerce implementation.
  • Lucene/Solr: we can implement this open source, advanced search functionality to provide Google-like search results, with relevance percentages reported back to the user.
  • Endeca: we can implement this enterprise search functionality, and provide advanced e-commerce flexibility and information presentation capabilities. Example features we can implement: products can be presented based on availability; landing pages, category lists, navigation, labels, and more can be created dynamically; and intelligent searching enabled based on a dynamic dictionary generated and maintained by user-entered and administrator-entered data (allows for many presentations of data based on what the user meant to type; very helpful for commonly-misspelled products).

• Mac and PC/Windows Server Environment Experience
  • Mac:
    • We have programmed web services to ensure they work in Safari (though Safari usually handles compliancy well).
    • Though we don't seek to do technical services work on Apple products, we have two team members that are certified to repair Apple machines by Apple.
    • We know Linux, which is based on Unix, and Mac O/S is based on BSD. Though we don't use the MAC O/S often, our Linux knowledge along with our general knowledge of technology allows us to navigate it and find answers quickly if we don't know how to do something right away.
  • PC and Windows Server:
    • We have programmed web services to ensure they work on the most popular PC-based web browsers.
    • Though we don't seek to do technical services work on PC products, we have several team members who have certifications and/or formal collegiate training in the support of such technical services.
    • We've supported or managed the support of PC's and server environments since 1995.
    • Collectively, prior to putting our focus on software development, we have done over 35 Windows Server implementations. Examples of what we can do: Multi-site Active Directory, Group Policy with advanced .vbs and .bat logon scripts, DNS/DHCP, Distributed File System, Routing & Remote Access for VPN and WAN connectivity, Exchange Server, SharePoint Portal Server, and Internet Information Server. Having this knowledge really helps us connect our web services to Microsoft-driven services. For instance, we can have the authentication system of an Intranet or Internet site be driven entirely off of Active Directory.

• Linux/Apache
  • Our systems administration skills in the Linux community are advanced.
  • We've managed Apache and sendmail processes since 2001 at Up and Running and for customers.
  • We maintain a virtualized machine that hosts redundant firewalls, as well as production, test, database, and staging machines.
  • We use memcached to increase scalability and performance. This is "a high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load." (Source: http://www.danga.com/memcached/ )
  • We have used apache mod_rewrite to protect a web accessible folder and modify the requested url to call a wrapper script that can use a web application's security system to access the file. This is beneficial in that standard FTP and HTTP file operations on the webserver continue to work as defined, and are enforced by the web application.
  • Most web applications we've written also use email communication, and we've written a set of routines to handle these tasks for us in PHP.
  • Examples of services we’ve deployed:
    • Asterisk solutions, including custom programming.
    • We have designed a centralized HA Asterisk environment that will accept and authenticate calls from remote PBXs on the same VPN using SIP registrations. This HA solution utilizes Heartbeat (formerly Linux-HA), DRBD, and custom socket monitoring scripts for STONITH for failover between nodes. All remote PBXs register to this cluster, and all inbound and outbound traffic as defined in their dialplans is pushed via 120 SIP trunks from the service provider. This is a robust, scalable solution (in its current incarnation it can support ~20 remote nodes), and is ideal for rural environments.
    • Multi-site Asterisk solution deployments.
      • Unified messaging: the ability to capture many different forms of communication (fax, email, voicemails, SMS, etc.), and deliver them to a single location, accessible by various devices, including computers, smart phones, phones, web accessible devices, etc.
      • Voicemails can be emailed to one’s inbox, and filed electronically.
      • Extensions that allow you transfer calls to cell, home, and other phones, making it seamless for the caller.
      • Custom menus for easy navigation for commonly-used features.
      • Remote access to phone and messaging system over a secured internet connection.
      • Custom software for call accounting and tracking for a billing system.
    • Postfix/Sendmail services.
    • POP3/IMAP mail servers.
    • MySQL and PostgreSQL database servers.
    • BIND master/slave DNS servers and replication.
    • Samba file shares for cross-platform access.
    • Samba Windows domain emulation.
    • Commercially-signed certificates.
    • Intrusion detection services.
    • FTP/SSH services.
    • VPN systems.
    • openVPN.
    • IPSec tunnels.
    • IPTable setups for complex router configurations.
    • Version control solutions for programming or updated documentation projects.
    • Open source backup solutions.
    • Server monitoring tools.
    • Workstation environments for office workers, programmers, and system administrators.
    • VMware infrastructures that host redundant firewalls, as well as production, test, database, and staging machines.
    • Distributed and grid computing.
    • Deployment of co-located servers for customers.
  • Distributions we've used:
    • Cent OS
    • Debian
    • FreeBSD
    • Gentoo
    • Knoppix
    • Slackware
    • SuSE
    • Red Hat
    • RHEL
    • Ubuntu

• Networking
  • This is not a skill we’re looking to provide to customers. However, we like to write about it so you know we have these skills. We welcome questions regarding network approaches as this is important for your IT infrastructure.
  • Systems and Topologies we’re familiar with:
    • Cisco 2500, 2600, 3000 series routers, and IOS.
    • Juniper routers and IOS.
    • Custom-built redundant routers in a CARP arrangement, utilizing pfSense.
    • Multi-site WAN connectivity.
  • Mediums we’re familiar with:
    • Copper 10/100/1000 links.
    • Multi and single mode fiber links.
    • Multi AP wireless networks covering entire buildings.

• Performance and Scalability Experience
  • We build performance and scalability into our systems because it’s natural for us to do so. Best practices lend to a scalable and high-performance system, and these must be implemented and followed at all levels of a software development project: at the design and architecture level, at the functional (programming) level, within the database setup, within the systems administration configuration, and within the business processes themselves.
  • We also know when performance and scalability design should be ignored. Of course, if the system is only used for a prototype or concept or for a small set of users, then the right amount of resources and best practices must be used so that value, as our client defines value, is maximized.
  • To demonstrate our knowledge of scalability and performance measures and best practices, we’d like to include some specific examples:
    • Apache optimization: there is a wide variety of settings (maxconnections, requestsperconnection, filehandles, modules loaded, etc.) that can greatly impact the performance of an instance of Apache.
    • Autoload: autoloading class frameworks is critical in large PHP applications to avoid high procedural processing overheads. Also, only lazy load objects as needed.
    • Be mindful of the size of objects you cache in session: course grain calls make sense to minimize database resource consumption, but composite or grouped objects can consume substantial resources on high-traffic sites, even those clustered and load balanced.
    • Cache when you can: Memcached is quite fast, and helpful in this respect. As it scales really well, we've also used Memcached (and Memcachedb) as a store for common information like user accounts, profile data, etc.
    • Connection management: Apache needs the correct number of client connections set, which is usually based on the amount of RAM available / resident size so swapping isn’t necessary.
    • Dependency management: avoid cUrl calls and microtime any web service calls that are dependencies. Be mindful of the impact of external dependencies: Google (especially Analytics), Amazon/A9, Akamai, and ad servers are notorious blockers with high average latency impacts.
    • Efficient, full-text searching: for full-text search, Sphinx is blindly fast, and it can also be used for fast lookups like email -> uid to stay off the MySQL servers. This is especially good if sharding is used, as it's a great index for determining which partition to find a user/object/etc. on. We also have experience with other advanced search solutions.
    • Ensure lightweight calls: seek low overhead on calls that are meant to be fast. AJAX, server-side code, for example, should be extremely lightweight.
    • Latency is key: web service calls should be handled efficiently. Offload services like sending email, processing credit cards, etc. to background processes dedicated to this so Apache sessions are not left open consuming resources unnecessarily and expensively.
    • Module management: statically compile all modules (small gain), and remove all unneeded modules. Resident size is very important; many configs have all modules dynamically loaded via LoadModule, which doubles the size of Apache. Not taking these measures might result in needing to double capacity to handle connections.
    • Normalize or don’t normalize: design a normalized schema, and then break that normalization if needed to gain efficiency increases (normalization is a guideline, not a hard and fast rule).
    • Pick the right tools and foundation within PHP: choosing the right tools and foundation is integral for scalability. For example, most common frameworks are not designed to deal with a large load. Also, templating systems are just attempts to reimplement PHP in PHP. As another example, it’s best to avoid dynamically loading classes/class_exists() and relying on include paths; using a constant like MYLIBPATH and including all things relative to that is preferred.
    • Query optimization: run EXPLAIN on each query over a certain time threshold.
    • Serve only dynamic pages in Apache: offload the static content to lighttpd+varnish or a CDN such as Amazon S3 or Akamai. Contrary to popular belief, Apache+mod_php is usually faster than using a FastCGI implementation.
    • Sharding and partitioning: once a certain size is reached, it becomes very difficult to scale MySQL. It's important to logically partition/shard your data at this point. With the 300m users we supported for one site, the user database we developed was sharded into 8 physical MySQL clusters, each with a master and slave.
    • Statistics tables versus counting/grouping dynamically: instead of counting how many products the customer has purchased each time, store that count and update it when it changes. Keep triggers/stored procedures/etc. out if at all possible.
    • The right data interchange format is important: JSON (and serialized PHP if you can stick to one platform) is a lot faster for IPC than XML.
  • Example applications of our performance and scalability knowledge:
    • thetravellingprince.com
      • Description: We implemented the site layout, database structure, and the business logic for a Home Exchange (where two members stay in each other’s homes for a vacation).  The system involved a complex search system that allowed visitors to search for properties based on dozens of different parameters.
      • Database Size: The site uses multiple large database tables, including a 7 million record Geonames database and a large table of properties.
      • Functionality Similarities: The site has a comprehensive search feature that matches visitors who want to visit a particular location with visitors who own a property in that location.  It features searching and filtering on many facets, including location, date of visit, duration of visit, as well as dozens of other tags and parameters.  Visitors have the option of performing an initial search and then drilling down, or expanding their search criteria if they find too many or too few records within their initial search.  In addition to the primary search run by the user, the system also performs "border" searches that find similar results by slightly modifying the parameters provided by a user.
      • Number of Users: The site has been designed to support hundreds of concurrent users and as many as 100,000 properties in almost 7 million different locations.
      • Relation to Performance Optimization: The search functionality involves very intensive queries to the property and location databases in order to locate both direct and "border" results.  In order to maximize the performance of the search functionality, we use multiple, heavily-indexed cache tables.  These cache tables provide a very noticeable performance improvement over querying the data tables directly, and allow searches to be performed in seconds instead of minutes.
    • voices.com
      • Description: We worked on the user interface design (not graphics, but the processes for visitors to use the site), database design, administration features, shopping cart, member sign-up, API for partners, and the communication system (internal email combines with external email). Also, the job process for this client is extremely complex, allowing for milestones by job, deposits tied to the milestones, releasing funds at certain stages, managing the agreement between the parties in the job, maintaining the data files, and attributing the file with the right step in the process. Other features of the site we contributed to include a profile section, feedback section, and search.
      • Database Size: 1.2 GiB; 6.7 million records.
      • Functionality Similarities: The database member search functionality permits an extensive filter selection, and these can be drilled down into or selected on the top level. Corresponding data is pulled according to the search criteria and the desired results. The search feature is the guest feature most often used.
      • Number of Users: The site has 65 thousand registered members. On average, thousands visit daily.
      • Relation to Performance Optimization: The home page utilizes some very SQL intensive functions that were taking up to 90 seconds to perform. We optimized the page, getting the search results to load in under 1 second.  Furthermore, on the admin and internal parts of the site, we optimized the functions that interact with the database, both by changing the structure of the database and the server configuration, as well as the code for the search. The work minimized the return times on complex reporting, and allowed the site to function significantly better during peak times (when new job notices go out and everyone is logged in to submit their bids for them).
    • Can’t Name Company due to NDA
      • Description: Consistently a top 100 site in Alexa rankings. We used our best practices to contribute to their backend architecture in the same manner we would for any client.
      • Database Size: We don’t know, but they get over 30 million unique visitors/month.
      • Functionality Similarities: This is quite larger.
      • Number of Users: We measure users in millions of DAUs (daily active users).
      • Relation to Performance Optimization: High relation.

• Experience in using and interpreting web standards (browsers, accessibility, and validity)
  • We develop according to W3C standards, and write code to enable browsers that do not always conform to W3C standards.
  • We stick to the standards as much as possible and when we can't do that, we use industry wide/supported alternatives to achieve the desired functionality.
  • We use transitional HTML 4.0 or transitional XHTML 1.0 doc types for our pages. This limits the occurrences of "quirks mode" being enabled, reducing most of the display discrepancies experienced between browser platforms.
  • We also design our pages in a DIV/CSS style layout, making it very easy to present the page differently using alternate style sheets. This same design enables us to write for screen readers or brail readers just as easily. We can also format pages to display on handhelds.
  • Our framework, retired except for specific implementations, can support alternate configurations of the data for different viewing mechanisms. For instance, we can provide a full Web 2.0 interface for regular browsers, and, with the same data, have a complete set of alternate views for use with a PDA or screen reader, which typically cannot handle JavaScript.

• Licensing
  • We utilize open source products in our applications that are business friendly.
  • We restrict work with GPL, OS 3.0, or other viral licenses to work that will comply with the business' objectives without compromising their intellectual property.
  • We favor LGPL-like license terms as these permit the distribution of the software without the requirement that the intellectual property added around the licensed software be compromised or licensed under the open source license agreements.
  • We provide recommendations and advice on the various open source licenses and the impact utilizing the software under these licenses will have on the project's IP rights.
  • We strongly support proper software IP management for reduced liability and compliance throughout the project.

• Systems Architect Experience
  • We have served as Systems Architects for many clients.
  • We know both worlds. We have technical skills at the micro and macro levels, and we can move between specialist and generalist-level thinking quickly as needed. In summary, we can implement and architect, which allows us to contribute more in both areas.
  • We believe the ability to organize a system arrives after understanding the processes and components of that system, in this case the system that enables the development, deployment, and maintenance of software. There are the technical aspects (hardware and software), the process aspects (methodologies for software development and communication, systems architecture, managing people, managing projects, client interaction, and more), and finally and most importantly, the ability to assemble a good team and create the environment that enables and promotes success. All of these must be done while balancing scope, money, and resources. Each project offers its own challenges and rewards as each project requires its own mixture of these elements.
  • We know how to research options for all aspects of a software project, and present these options to stakeholders intelligently. We know that each stakeholder has his or her decision factors, and that it's important that they be able to assess options easily and quickly. We also understand that we should give our recommendation if it's applicable and state pros and cons of a particular decision as it relates to the software development teams' effectiveness.

• Graphics Design
  • Our team has studied UI design, and has been applying it for years; we believe we've helped improve navigation and usability for many websites.
  • We have basic graphics development skills (Adobe products and GIMP), though we prefer to seek professional design help for graphics, content, and the more aesthetic aspects of website creation. We enjoy more and believe we contribute most to working on the engine of the software system.
  • We do understand design in the sense that we know it's challenging, is complex, and requires the mastery of several arts, similar to software development. We have enough knowledge to communicate well with designers and graphics development teams, and have done so successfully on many projects. We have served as the software development contact for design businesses and communications departments. When our arts combine, we think great things happen.

• SEO/SEM
  • We have professional working knowledge of this. However, to do this extremely well, depending on the site, this could easily be a full-time position in and of itself.
  • We have team members that did this professionally prior to joining Up and Running. One of them wrote the tools that one of the major SEO/SEM company uses to perform their SEO/SEM operations. Thus, we have knowledge at a very low level of SEO/SEM activities.
  • We’ve also helped one of the major SEO/SEM companies in the market place with their software development, and they like working with us because of our contextual knowledge.
  • We’ve provided consulting for agencies who needed SEO/SEM help.

• Tools: These are the tools we use to organize work, communicate and collaborate with others, and get work done faster. We've used many, and can adapt to what your preferences are.
  • Version Control System or Source Configuration Management (SCM): We use Subversion (SVN) to manage our codebase. We also use Concurrent Versions System (CVS) for some of our customer projects.
  • Collaborative Software: wikis, SharePoint, Google Sites, Basecamp, Exchange, and custom Intranets
  • Communication: email, VOIP on an internal Asterisk solution, SmartPhones, Skype, and Pidgin with most IM accounts
  • Desktop Sharing: WebEx, GoToMeeting, Dimdim, Yugma, Ultra VNC and CrossLoop
  • Bug Tracking: Mantis and FogBugz. We have used Bugzilla, RT, and Flyspray.
  • Project Management: spreadsheets (We believe Excel or Google Docs can accomplish most PM needs; people and processes are more important than the tool.), Microsoft Project, SharePoint, Basecamp, and custom systems.
  • Browser Testing: Firefox's Web Developer Toolbar and Firebug and IE's Web Developer Toolbar. We also run VMware to QA systems on various browser versions: Windows XP Pro with IE7, Windows 2000 with IE6, Ubuntu with Opera and Konqueror, and more. Finally, there are some great browser testing tools out there like BrowserShots and CrossBrowserTesting.
  • Editors and/or Integrated Development Environments (IDE): Gvim/Vim, Eclipse, Visual Studio, and the Linux Command Line.

• Advanced Search Solutions
  • We've written a few full-text index search systems that index content information in MySQL and PostgreSQL. The most complicated search system we've written is within our custom framework; it can take a system object, use reflection to process its getter methods and child relationships to generate an index list, and store that in a generic search table. A system-level search then allows those object items to be pulled up off of keywords, and directs the user to correct views that render that object's data. It's fast, flexible, and allows for any model data to be searched for and displayed.
  • We've implemented and customized Google Search appliances for customers.
  • We know Lucene/Solr, and can implement this open source, advanced search functionality to provide Google-like search results, with relevance percentages reported back to the user. This can be very useful for e-commerce implementations or for websites where there is a lot of data. As an example, we implemented this for a job and candidate management site; the result was that they had far more transparency into their job and candidate data, which helped them and their end users accomplish their objectives faster and with more accuracy (better matching between job needs and candidate capabilities).
  • We know Sphinx, an open source, full-text search engine. Here’s more about this: http://www.sphinxsearch.com/about.html
  • We know Endeca, a commercial, enterprise search tool used to provide advanced search and information presentation capabilities. Example features we can implement: products can be presented based on availability; landing pages, category lists, navigation, labels, and more can be created dynamically; and intelligent searching enabled based on a dynamic dictionary generated and maintained by user-entered and administrator-entered data (allows for many presentations of data based on what the user meant to type; very helpful for commonly-misspelled products).

• Technologies that we're not an expert at and that we're often asked about: Here's how we usually answer when asked if we know a tool based on programming languages we know: understanding the primary underlying technologies (PHP & SQL, for example) is the key. Our learning curve is more of a flat line when it comes to using most tools. Another way to present this is: we have theory and experience across many tools, languages, and processes that we can apply regardless of the new widget, tool, or methodology. We're not claiming to be an expert at everything or overconfident/arrogant, rather highly-adaptable professionals when it comes to any tool related to web services based on the technologies we’ve built our business around: PHP, SQL, JavaScript, XML, Apache, and Amazon Web Services.

Return to top

---

• Usability
  • Many of us subscribe to Jakob Nielson's, one of the industry's noted experts on user interface design in respect to usability, alerts, and have studied user interface design. Our primary concerns are usability and flexibility when creating a UI. Several of our team members have read these books so that we can work better with copywriters and designers, and design better ourselves:
    • “The Design of Everyday Things” Amazon link
    • “The Inmates Are Running the Asylum” Amazon link
    • “Homepage Usability: 50 Websites Deconstructed” (by Jakob Nielson) Amazon link
    • “Designing Interfaces: Patterns for Effective Interaction Design” Amazon link
    • “About Face 3: The Essentials of Interaction Design” Amazon link
    • “Observing the User Experience: A Practitioner's Guide to User Research” Amazon link
    • “The Design of Sites: Patterns for Creating Winning Web Sites (2nd Edition)” Amazon link
  • We know and have applied these usability techniques: “hallway” usability tests in person and online, formal and full usability tests, surveys, interviews, contextual inquiry, card sorting, user elicitation, experience sampling, eye tracking, cognitive walkthroughs, GOMS, competitive analysis, heuristic evaluation, persona development, scenarios, flow or interaction mapping, and log analysis.

• Copy: we don’t usually write copy, but some of us have. Here are some of the books we’re read about this:
  • “Waiting for Your Cat to Bark?: Persuading Customers When They Ignore Marketing” Amazon link
  • “Call to Action: Secret Formulas to Improve Online Results” Amazon link
  • “Persuasive Online Copywriting: How to Take Your Words to the Bank” Amazon link

• Agile Development
  • We believe in the Agile methodology for development and deployment of software because of its focus on the customer and the customer's feedback.
  • We've used more standard forms of development life cycles, such as the waterfall methodology. We recognize the importance of following the customer's preferred means of doing work, and are able to adapt to any software development methodology.
  • We believe this methodology is responsible for Up and Running being able to deliver products that customers use and like.
  • Due to the high levels of customer and user interaction we incorporate within our projects, our systems are well received. We believe in user-focused, interface-driven software development because if the system is not usable, it will not be used in most cases.
  • Testing:
    • We believe in using a test process that involves all stakeholders: primary programmers, peer programmers, quality assurance specialists, project managers, the customer, and, most importantly, the user.
    • We believe developers should use these tools and methods to test their work: Peer Reviews, Unit Testing, Automatic Build Testing, Test Cases, User Story Confirmations, User Interface and Navigation Checklists, and Development Completion Checklists.
    • We think project managers and quality assurance specialists should use these tools and methods to check a developer's work: Test Cases, User Story Confirmations, and User Interface and Navigation Checklists.
  • We use tracer bullet development (Hunt, Andrew and David Thomas. The Pragmatic Programmer: From Journeyman to Master. Addison Wesley, 1999.) on larger scale systems to retrieve faster feedback from customers on UI designs and system workflows. Amazon link
  • Besides the book mentioned above, many of our team members read books on the subject, such as:
    • “Agile Retrospectives: Making Good Teams Great” Amazon link
    • “Practices of an Agile Developer: Working in the Real World” Amazon link
    • “Release It!: Design and Deploy Production-Ready Software” (less Agile, but applicable) Amazon link
    • “Ship it! A Practical Guide to Successful Software Projects” (less Agile, but applicable) Amazon link
    • Besides the above, we have read books on estimation, managing software developers, and the requirements gathering process.
      
      
• Leadership
  • Up and Running has grown from a single person in 1995 to an organization that has 30+ employees, and serves customers across the world.
  • We recognize that leadership is setting the direction, and that management is ensuring that direction is fulfilled efficiently.
  • We know the relationship between Vision, Mission, Values, and Strategic Goals.
  • At the start of software projects, we like to ensure that the vision and mission of the project is in direct alignment with the client's vision and mission.
  • We think it's important that people and projects have their own organization-focused vision, mission, and goals.
  • Many of us read books by Jim Collins, Peter Drucker, Stephen Covey, Tom Peters, and others on leadership and management topics.
  • Several of our team members subscribe to Harvard Business Review, McKinsey's newsletters, and other leaders in the management and business arena.
    
    
• Management
  • We believe a manager needs to set the stage for success, and do whatever is needed to help team members achieve success.
  • We have learned how to assess potential team members, as well as ways to quickly learn if someone is capable.
  • We have hired and fired people; though we don't enjoy the latter at all, we view it as a responsibility if the person is not improving after being given the opportunity to do so once given objective, constructive feedback.
  • We have led, coached, and mentored other team members, and enjoy learning from our team members, our team lead, and all other peers.
  • We have read materials on how Microsoft ("How Would You Move Mount Fuji?" ( Amazon link ) and Google (online) hires, and have created two interviews to test for developer aptitude.
  • We've written template job descriptions and responsibilities for enterprise webmasters.
  • The Agile books we've read help us to be better managers operationally.
    
    
• Team Work
  • The foundation of a project's success is its people and the relationship between those people. It's important for the team members to have a shared goal, the tools to do their job, the knowledge to do their job, and respect and trust for one another.
  • We have been working with customer teams since 1995 to deliver technical solutions.
  • We have experience working with remote contractors and developers using various tools to manage projects, time, and collaboration.
  • We have led, coached, and mentored other team members, and enjoy learning from our team members, our team lead, and all other peers.
  • We're used to working remotely, and can deliver results doing so.
    
    
• Interpersonal and Oral/written Communication Skills: We hope the letters of recommendation, testimonials, and kudos attest to our abilities in these areas. English is our primary language.
  
  
• Analytical Abilities: Most of our team members are engineers at heart that understand the need and value of developing one’s ability to communicate accurately and consistently. A common trait among engineers is the ability to think analytically, and we believe we’re consistent with this ascribed generality.

• Customer Focus
  • In alignment with our agile development processes, we work closely with the client stakeholder team to understand requirements, system specifications, and design. This is standard operating procedure, and something we believe is very important for the success of a project.
  • For our requirements gathering sessions, we generally approach them using a workflow-based framework as defined in this document, "Up and Running -- Workflow Analysis Introduction.pdf" . This is part of our overall solution design methodology, as defined in, "Up and Running -- Solution Design Methodology.pdf" .
  • We also maintain the perspective that it's our responsibility to ensure the system does what the end users want. We don't believe it's easy to define requirements, and this is why the Agile programming methodology is so appealing to us; it allows the customer to see how the system is progressing and to offer feedback at every iteration. The end result is a very nice product because it does what the users want and how they want it, meaning that the system will actually get used and not sit on a shelf.
    
    
• Business and Technical Communications: We understand business operations and software development operations. This allows us to bridge the two worlds well, meaning we're very helpful at translating end user or business line requirements into functional or software development requirements. In other words, we can talk business and "geek". Examples:
  • Since 1995, we've worked with several hundred clients across the nation and world, helping them translate business needs into technical or functional requirements, depending on the type of technology solution needed.
  • For one client, we wrote and implemented an entire Manufacturing ERP to manage their manufacturing processes.
  • We implemented a system for another client to lend more transparency to their project workflows in addition to streamlining payroll and customer invoicing processes.
  • For another client, we developed software to improve the quality of product delivery throughout all post-order operations management.
  • We have a long list of clients we’ve helped. What we hope have demonstrated is that our core foundational skills in software development, business, and communications enable us to contribute in any sector for any workflow.

Return to top

---

---