Professional Projects

My development background is almost a double life; what I do professionally in my career and what I do recreationally at home. One of the major differences is the technology involved. While I use an array of publically available technologies and tools in my personal work, my professional work is soley focused on using Microsoft technologies.

This section covers the projects I've done throughout my professional career and provides a few details around the technologies used for each. This is not meant to be a resume, and as such, many of the specifics about my employer and our clients are purposely left out. In addition to keeping that anonymity in tact, it also allows the features and technologies involved to get all of the focus.

Project List

My professional career has had many turns. Starting out as a developer, I worked on client-facing projects for the first few years. After putting in my time and a few lucky breaks, I was given the chance to become a development manager. At that point, my development time was done on the side and focused on helping my developers work more effectively and efficiently.

Most recently, after our company was acquired by a much larger organization, I have gone back to being a lead developer, working on a product-driven development team. The projects below are broken down along those turns.

Project Details

The following projects are listed in roughly chronological order, from earliest to latest, starting from about the end of 2001.

Partner Reporting and Resource Tool
Technologies: VB 6, Classic ASP, SQL Server 7.0
November 2001

This was an existing web-based application that I inherited when I started my first job out of college in November of 2001. It was an N-tier application that used what is now called "Classic" ASP as the presentation layer, COM+ components written in VB 6 as the business and data access layers, and SQL Server 7 as the database backend.

The main functions of this portal application were to provide users of our clients and their partners a read-only, web-based inteface into our volume license management solution. This include the ability to run standard and custom reports out of a relatively simple data warehouse, as well as controlling access to price lists and other license agreement information.

 

Support and Project Tracking Tool
Technologies: Classic ASP, SQL Server 7.0
July 2002

This project was the first professional web-based application that I was asked to build from the ground up. It was to replace the existing Lotus Notes based support ticket system we had been sharing with our sister company with something that was completely web-based and was even to be made available to our clients 24/7.

In addition, we had goals to make this our online project management and work assignment tool, which didn't seem like a tall order at the time because we only have 2 project managers and a handful of developers.

It initially started as just a prototype, using VBScript and Classic ASP to connect directly to a SQL Server 7 database. The initial demos went so well that it just sort of grew out of that without a real chance to rework it into a more traditional N-Tier model. What started as a prototype in the summer of 2002 turned into a fall launch to the entire organization in only a mere 2 1/2 months time. We ended up using this tool internally and with customers for the next 4 years.

 

Software Volume Licensing Quoting System
Technologies: ASP.NET 1.0, VB.NET, SQL Server 2000
November 2002

Shortly before finishing up the support tracking tool, one of our larger emerging clients at the time needed a better solution for the existing quoting system we had in place for their sales team and their partners. It was time for me to become engulfed in the business logic and rules engine of our legacy software volume license management system and bring that to the web as our new, internally built quoting engine and interface.

As with some of the other demos I was building out at prototypes during this time, this quote tool was originally targeted for one of our top prospects (who just happened to be one of the top 5 software companies in the world). After about 3 months of hard work and the normal changing requirements, we were ready to go live when the deal fell through. So we ended up picking things up with the same project to one of our emerging clients, which happened to be looking for something new along the same lines.

This was one of the first ASP.NET applications that our company built, and it went back to the traditional N-Tier architecture that was being used at the time. It was written with ASP.NET as the presentation layer and components written in VB.NET for both the business layer and the data access layer. We had recently upgraded to SQL Server 2000 (over version 7), so that became our standard backend. This model (and much of the database schema) because our standard application platform for the next 5 years with more than a dozen applications and sites being built on top of it.

 

eCommerce Site Generator and Content Management System
Technologies: ASP.NET 1.1, VB.NET, SQL Server 2000
May 2003

By this time, our company's eCommerce capabilities were starting to take shape. We had proposed building a system that would allow us to generate and configure different websites for eCommerce that would all feed from a standard code base and database backend. I had helped prototype the system years ago in Classic ASP, but it was given to one of our vendors at the time since I was given the quote tool system to build.

The vendor that built our initial eCommerce system left a lot to be desired, and what they provided us had more than a few shortcomings. As we looked to increase our client base with eCommerce services, we needed to rebuild from scratch and chose to put it on our ASP.NET platform.

There were a few good designs that were implemented from our original prototypes, so it was just a matter of reimplementing those in .NET and work out some of those shortcomings. In a matter of three weeks, I had rebuilt the system and added about a dozen additional featuers that were not possible in the previous version. I turned it over to the other team members once I was done with it, leaving them a few pieces to finish up. This system lasted for about 4 years and hosted the highest volume eCommerce site our company ever saw.

The content management portion of this system allowed our support team to manage site changes and for our developers to put up new sites for new clients in just a few weeks times. We hosted sites in more than 8 languages, processed orders in 6 different currencies and supported more than two dozen countries.

The content management system itself was a series of database tables and a dedicated web frontend that we added to our existing application database platform. It was still built using ASP.NET, and if we had to do it again, we would have chosen to use user controls to customize portions of the site. Over the course of it's life, the business and data access layers were maintained and modified by more than a dozen different developers, all ensuring that their changes followed the original design guidelines of the system to ensure consistency and standards.

Overseeing the design and development of this system and our growing eCommerce client base is part of the reason I was given the opprotunity to lead the team as the application development manager.

 

Software Maintenance Renewal Generation and Notification System
Technologies: ASP.NET 1.1, VB.NET, SQL Server 2000, SQL DTS
September 2003

Sticking with the complexities of the anti-virus area, we found another software publisher with a different problem. They were looking for a solution to get their end user customers to renew their licenses of their anti-virus, backup software and other products. These customers were large corporations with multiple locations and child customers, all that had their own license numbers, purchases, quantities and expiration dates.

On top of that, there were licensing rules that we had to accomodate, for example, requiring customers to upgrade to the latest version of a product. In some cases, those customers were running different versions in different offices and all needed to be renewed to a single version. To make it even more interesting, there was no "closed loop" for previous renewals, meaning that if a customer had already renewed, it was tracked anywhere in their system. What that meant was that we had to create a reconciliation process to match recent orders to previous purchases and cancel out what qualified as a renewal.

The final output of this project was a monthly process that we would run to generate PDF renewal letters that went out electronically to our client's customers. It also featured an online portal that was used by internal sales representatives, assigned by territory, to view automatically generated renewal quotes for customers in their regions, with both the original purchased and suggested renewal products and pricing. It also featured an audit trail where representatives and their managers can view activity and history on a particular quote.

Those same quotes were also available to a partner version of the portal, where they could also see renewal quotes for customers that previously purchased through them. The reseller community, however, would only go after the higher end renewal quotes, so much of the activity in the system was internal sales users.

The system also featured as presentation layer built with ASP.NET, and VB.NET business and data access layer. There were also about a dozen DTS packages in SQL that handled various data feeds and processes for renewal generation, order data loads, product version mapping, and renewal statement notification. There was also the addition of a multi-layered user security system that involved mapping sales people to their managers and territories and having that heirarchy of access and visibility into reporting. The system ran for about 3 years before it was taken in house by our client.

 

Guided Selling and Product Configuration Tool
Technologies: ASP.NET 1.1, VB.NET, SQL Server 2000, SQL DTS
April 2004

After the quote tool was completed, it was time for our organization to get more business. This project was for a well-known antivirus and security company that was looking for a better way for their sales force and their reseller partners to configure and quote on the growing and complex world of their security software and hardware offerings.

It consisted of various methods of finding and configuring a solution of products, including a direct lookup and a product dropdown list, similar to the one that was built in the previously mentioned quote tool. But the real selling point of this configuration tool was the ability for a sales person to go through a series of related questions that were intelligent enough to update based on the previous answers. The end game was a set of products that can be customized to the customer's needs.

The questions and answers (as well as the other site content) was stored in a database that was administered by a separate web application which the client could manage themselves. It was also stored with associated locale information so that the entire site could be translated and localized, although the client never utilized this feature.

This site was built with the same ASP.NET front end and VB.NET business and data access layers. The database for this application started as a replica of the quote tool with the addition of the question and answer and localized content components. There was also a separate price and configuration component that was created to replicate the pricing logic that our clients internal systems used. It was set up to read from a separate database for pricing, which was updated daily with price files that were received via FTP and loaded via Data Transformation Services (DTS).

 

Technical Specifications and Code Generator Tools
Technologies: ASP.NET 1.1, VB.NET, SQL Server 2000, XML, XSL/T
January 2005

After leading the development team as a peer, it was my chance to take the helm and become the development manager in February of 2005. That also meant my days of coding for our clients was just about finished.

That didn't curb my coding contributions to the organization, though. With my focus now shifted towards how to increase the productivity and the efficiency of our team, which consisted of 4 senior developers and 6 junior developers. I took it upon myself to build out our own development toolkit to help manage and track our development.

The first tool I put together was a way for us to quickly write up and better organize our technical specificaitons. It was a web based application that the senior developers would run locally on their machines, and even offline if they wanted to. The datastore used for each specification was a set of XML files that was managed by a series of web forms and all the reports and view pages where presensted using XSL/T stylesheets. This made for very rapid development and customization on my part, which allowed me to add features almost every other day.

After amount a month, I added some simple code generation to the mix as well, again using the XML and XSL/T approach. Since the developers were defining SQL tables with all the required details, and since our stored procedures were following specific design guidelines, simple Create, Update, Retrieve and Delete (CRUD) procedures could be created automatically. With a standard data access layer for all of our database access, those were generated, too. It paid great dividends in productivity because a good part of the stub code was being generated straight from what the senior developers were documenting.

 

Source Code Analysis and Code Review Tools
Technologies: ASP.NET 1.1, VB.NET, SQL Server 2000, XML, XSL/T
September 2005

One of the challanges we faced with a team of 10 developers writing code for different applications was trying to keep some sort of standards upheld within the code. This allowed us to have developers switch projects or help out with someone else's work and require only a short learning curve to figure out what the code is doing.

To help, I created an application that would scan through our source code and look for 42 different coding conventions and report them back as violations. By giving these tools to our senior developers, they could run them against source code checked in by the junior developers and review the results with them, allowing for mentoring and coaching.

In addition to help with the code reviews themselves, which we hadn't had in our organization prior to that, it was about this time where I started working on functionality to help schedule and track code reviews as part of our technical specs process. The system was now setup let the senior developer plan out which parts of the tech spec was to be reviewed for a particular code review and create a sub-document with just those details. As part of the review meeting, the senior developer would take notes during the discussion with the junior developer, as well as adding a set of todo's at the end. The output of these code reviews was a report that was delivered to myself and the project manager and used in performance reviews for both the senior developers (as part of their mentoring responsibilities) as well as the junior developers.

Ultimately, with the tech specs in place, and a way to schedule milestones, estimates and code reviews off of a set of tasks, I topped this all off with a concept of a Development Plan, which the senior developers could create for my review and for giving to the project manager as part of the overall project plan. It helped open up some of the planning and development process that was previously a black box for our non-techinical project managers. Again, all of this data was stored as XML files and each report and document generated was done so with XSL/T.

 

Project Resource Assignment and Management Application
Technologies: ASP.NET 2.0, VB.NET, SQL Server 2000, XML, XSL/T
January 2006

Growing pains weren't necessarily restricted just to infrastructure. With a full development team kicking some serious butt, our sales team did their job and we were starting to get upside down. At the end of the day, we were still a custom development shop and a lack of change control from a project management perspective was putting the pressure on my team to meet some very aggressive timelines.

So, to help facilitate assignments and priorities among my team members, as well as to help me keep tabs on changing deadlines and project status, I started a new system to track and manage project status and resource assignments. What started as a simple project-to-developer list soon became very feature rich with the ability to assign resources to roles on a project, provide and track estimates for different tasks, track and illustrate conflicts and dependancies with resources, and much more.

One of the better pieces that came out of this was the ability to provide status and updates per project that was delivered weekly to the management team. These weekly updates included a dashboard that would at first show a list of all the projects in each status (such as In Development or In User Acceptance Testing) and then provide details for each with just a click away. Details included completed and upcoming tasks for that week, resource assignments and updates, general project descriptions, and milestone dates. Later versions would include time tracking per resource for a given week.

This update report was generated as an HTML file and sent as an attachment to the management team each week. The fact that it was an HTML file made it easy to format, generate and share, as well as for someone to view without having to open Word, Excel, or have something like Acrobat Reader or Microsoft Project installed.

 

Database Management, Tracking, and Analysis System
Technologies: ASP.NET 1.1, VB.NET, SQL Server 2000, XML, XSL/T
March 2006

Growing pains sounds cliche, but about this time, that's what we were running into. As I helped my team to manage multiple projects and applications in parallel, we were outgrowing our infrastructure. So, we started to virtualize our test environments and installed a large SQL cluster for managing multiple instances of our applications.

All good news, right? Well, without a DBA, it sort of fell on me to monitor and manage all the different environments that we had running at the same time, as well as to help with promoting changes from development all the way through testing and into production. So, I whipped out a few additions to my source code management tools that included functionality to analyze and document our SQL servers. From a list of server names, these changes would use system stored procedures and functions to scan and document all of our databases. It tracked table schemas, stored procedures, views and analyzed changes in each of them between different environments. At the end, I was also able to add SQL Job information based on MSDB information and procedures.

As space started to become an issue, I added capacity tracking and trending to the system, allowing us to see what databases were growing in which environments, and ways to archive and purge data that wasn't used on a regular basis.

 

Time and Task Tracking System
Technologies: ASP.NET 2.0, VB.NET, SQL Server 2000, XML, XSL/T
September 2006

As you could imagine with competing projects and resource conflicts, things weren't always delivered according to schedule. As a method of survival, some aspects of the development life cycle were being short-changed and handled by our senior developers to get things out the door faster. Quality was always our ultimate goal, but so was being efficient with our time and effort and making sure the right people were doing the right jobs.

To help measure effeciencies within my team, and to help look for ways to better streamline or delegate certain jobs, I started asking myself a few questions. Were we spending too much time on bug fixes? Were our code reviews too long, or were they even being held at all? How about production support, were the developers getting too many support tickets assigned to them?

So, it was time to start measuring. Again, starting simple, I created a small database with about 4 tables in it and a two web pages: a timesheet report and an time entry form.

Each developer would use the time entry form to select a date, project, task (i.e. write spec), and the number of hours they spent on it that day. The interface was streamlined so where the developer would have to spend no more than 2 minutes a day to fill out the form. And it helped.

Using this data as a mini-data warehouse, I started to generate some basic reports and analysis, first with just Query Analyzer and later with more HTML reports (using XML and XSL/T as with previous apps above). It turned out to be a very important tool in many aspects, including helping to manage the support queue better, looking for ways to add unit testing to help limit time spent on fixing bugs later on, and to help educate the senior developers on where their estimates were falling a little short in some cases.

 

Application Environment Tracking and Discovery Tools
Technologies: ASP.NET 2.0, VB.NET, SQL Server 2000, XML, XSL/T
December 2006

Since the database tracking application was beginning to help greatly, I looked for ways to push it even further. The next set of features I added was to extend this to the web applications themselves. These new features looked for configured web servers and processing their wwwroot folders and subfolders. It also read metabase xml files within IIS and supported differences with Windows Server 2000 and 2003 servers.

Once it found these wwwroot folders and the associated virtual directories, it started parsing details of each web application. It parsed web.config files and tracked connection strings to databases and other custom AppSettings, which were logged. It also read and logged application assemblies in the /bin folders, reading the assembly versions and timestamps and using that to build reports and compare differences in versions deployed to different servers in the same web farm.

 

SQL Job Monitoring Tools
Technologies: .NET Framework 2.0, VB.NET, SQL Server 2000
April 2007

As part of some turnover in our management ranks, part of my Development Manager role came to also include our production support team for about 9 months. In that time, I had a chance to help them out with some additional monitoring tools to keep tabs on our production systems.

The first was an application to monitor SQL Jobs from all of our SQL Servers. All of our web applications had some sort of backend processing, from sending confirmation emails and processing credit cards to transfering files and interacting with our warehouses. So, when they fail, we needed to fix them fast.

I had already built logic into my database management application to read in SQL Job information from the MSDB database in SQL Server, so I turned that into a console application that could be scheduled (unfortunately as a SQL Job itself) to use those same tables and procedures in MSDB to lookup job history and send out email alerts to the support team when they fail.

 

Additional eCommerce Sites
Technologies: ASP.NET 2.0, C#, SQL Server 2005, SOA
July 2007

Up to this point, our development team was still using the eCommerce Site Generator that I put together years earlier. As I had fallen out of the role of maintaining that system, it was becoming less efficient and more unstable as different contract developers we had hired had made custom changes without preserving the initial design. So, when we needed a new set of eCommerce sites for different clients and in a hurry, I was asked to step in and break out of that cycle.

In the matter of a month's time, I had put together a new architecture that replaced the outdated content management of the old Site Generator with master pages and resource files and the business logic layer with our first Service Oriented Architecture design. It helped modernize the next series of websites we put up for our largest client, making us more responsive to change and support more reuse in business logic than our previous Site Generator.

With this first eCommerce site that I created to use an SOA architecture, I was unable to streamline the database layer because it still had to support existing sites for the same client. It was about this time that our company was acquired by a larger organization, and one it was time for our little group to strut our stuff for the new owners, they put us right to the test.

I adapted the new SOA based website with a new streamlined SQL Server 2005 backend that removed about 75% of the tables and columns that our previous database layer had accumulated over the years. It lead to two new sites for our new larger company that were groundbreaking for them and earned us a strong reputation right off the get go.

 

Server Disk Space Monitoring
Technologies: .NET Framework 2.0, C#
January 2008

While server monitoring sounds like something most companies would have in place without thinking twice, we didn't. After being frustrated with our infrastructure teams and drives on our servers filling up with logs and going forcing our applications offline, I spent half a day to put together an console application similar to the SQL Job Monitor that would connect to a set of configured servers to check available disk space and alert when below a given threshold. Disk space was checked using Performance Monitor data built into Windows.

 

Tax Rate Web Service
Technologies: ASP.NET 2.0 Web Services, C#, SQL Server 2005
February 2008

With the acquisition of our company complete, we started going through a lot of changes. One of the first was an revelation that our previous, state-driven tax rates were just not good enough. We needed a new solution and couldn't wait the 6-9 months it was going to take for the integration into the corporate financial systems to leverage their tax calculations.

So, one other developer and I had two weeks to learn the correct tax rules for 12 different states and business rules that were custom to more than a few of them. Next, we had to identify an off-the-shelf service to purchase monthly rate tables that features state, county and city rate information. Then, we had to build out a web service that both our new and legacy web applications needed to consume to calculate tax according to these new rules.

It took a little midnight oil, but we were able to get it done in time and with only a limited number of defects that needed to be fixed.

 

Self-Service eCommerce Product Platform
Technologies: Commerce Server 2007, Microsoft Office Sharepoint Server 2007, SQL Server 2005
April 2008

After 5 years of building custom eCommerce sites for software publishers, we decided to take on our most ambitious initiative to date and build a robust, self-service platform to enable our clients to take complete control of every aspect of their own site. We have taken a product driven approach with this project, planning out features and building it to our specifications and what we feel our clients are looking for. This has been a big change for us.

On top of being a different approach from a project management perspective, we are also working to leverage fully supported Microsoft technologies for both the commerce engine and the content management and presentation layer for this product. The tools of choice for those needs were Commerce Server 2007 and Microsoft Office SharePoint Server 2007 (MOSS). It has been a long road so far, but we're getting closer.

We are customizing an implementation of Commerce Server to support a product catalog for selling software licenses and downloads, as well and extending out the orders and profile systems to accomodate volume licensing programs, download history, and other related features that have been part of our existing sites in the past.

On the presentation layer, the goal of the product is to allow full customization of content from a client's perspective, meaning they get access to change everything. To accomodate that, we've built out a large library of ASP.NET Web Parts as the toolkit by which our clients will be able to add functionality to their sites.

There have been numerous hurdles with this project so far, but we're getting close to the initial launch in the next few months (at the time of writing this). It's been a huge learning experience for everyone involved.

 

License Key Service
Technologies: WCF Web Services, .NET 3.5 Framework, C#, SQL Server 2005
August 2008

One of the core components of all of our eCommerce sites (new and old) has been the management of software license keys and what we call Electronic License Delivery (ELD). Until recently, we had desparate ways of managing this on a client-by-client basis since each software publisher manages and provides us with license keys in slightly a different fashion.

For our new commerce platform, however, and as part of our implementation of Commerce Server, we needed a more robust and consistent way to manage and deliver license keys as part of an order. So I was tasked with creating a new web service system for this purpose, and I chose to implement it as a Windows Communication Foundation (WCF) web service using C# and the .NET 3.5 Framework.

It turned out to be a very clean interface and again, a new, streamlined database design that I put together as a consolidation of various rules and functions we needed to support from past sites. The main features it is targeted to support include checking key inventory, managing key reservations as part of the shopping experience, managing key purchases as part of the checkout process, exposing integration points to be consumed by BizTalk for adding keys to the system, various analytical and accounting reports, and stock threshold notifications for alert when inventories are running low.