Technical Designs, LLC (independent)     Brookfield, WI             Present
Architect, Designer, and lead developer of RIA architecture leveraging ExtJS and
jQuery client side code.  I successfully have been able to train a team of
approximately 17 developers, qa, and managers on how to leverage javascript
frameworks to give highly responsive and high quality user experience web-based
applications.  All communication is done via ajax methods that give the user
immediate feedback that the application is working.  I have reduced post-backs
and page flicker to zero.  The quality of the frameworks allows me to create very
desirable looking web applications that rival what can be done with Flash and
WPF.  
Expertise in architecting and developing reusable frameworks.  Sites are
developed using well known design patterns that allow for significant code-reuse
by way of leveraging SOA based communication standards.  
Design and development of metadata driven n-tier application engine. 
Essentially, I wrote software to create software.  The current UI model is for
ASP.NET.  The server consists of WCF interface which allows for multi-threading
connections through the business rules framework and then connecting to the
back-end datasource.  The data source is defined through the metadata
architecture which allows for the application to always connect to the
authoritative data sources on the network.  Default configuration allows for SQL
Server 2000/2005, Oracle, MySQL, and XML files.  The business rules framework is
configurable and supports the ability for clients to write their own business
rules logic and the engine will be able to dynamically load the custom assembly.
Architect, Designer, and lead developer on “Command Center” concept. 
Essentially this is an ASP.NET application that is configured via a database at
run time to dynamically load user controls.  Each user control is pluggable which
allows for the application to be extended, new “Command Center's” to be created
at run-time without a need to redeploy the application.  User Controls are able
to communicate with one another through a sophisticated communication framework. 
This was designed and developed with the fact that we would not know the user
controls that would be on the page until run-time and thusly, we would not know
how or to whom each user control would communicate with.  By leveraging OOP
concepts like interfaces and polymorphism, we were able to get the controls to be
able to communicate dynamically and at run-time.  Technologies that were used
include: ASP.NET, C#, SQL Server 2005.
Design and development ASP.NET n-tier e-commerce / social networking
infrastructure.  Infrastructure allows for multi-tenancy within the data source. 
Data model was created using metadata methods which allows for data to located
essentially anywhere and application is able to retrieve it.  Application has a
business rules interface which allows for the owner to be able “on the fly” be
able to modify the behavior of the system.  System currently has multiple website
interacting with the backend simultaneously.  Architecture includes; ASP.NET UI,
Custom WCF based Application Server,  Sql Server backend.
Installation and support of Microsoft Office SharePoint Server, installation and
development of Web Parts, templates, and master pages.
Development of custom modules, integration of existing modules and 3rd party
products for Dot Net Nuke.

Metrix, LLC                                                           
Brookfield, WI          8/07 – 8/08 
Architect and lead developer of ASP.NET / C# based dynamic metadata driven
portal engine.  Essentially this is an application that is used to build customer
/ internal facing websites that are able to leverage all normal ASP.NET controls.
  All screens are configurable without code changes and recompiling.  The screens
are stored at the application server and passed over the wire when requested via
WCF (or as needed, a .Net web service).  Client caches screens (and domain data)
client side on two different levels (application and session).   Client side
Javascript data validation is dynamic and can be configured at run-time by making
changes to the metadata.  All data that is transferred over the wire is in XML
format and is manipulated using Linq to XML techniques.   The application
currently has two different views, 1. Customer focused workflow ability 2. Rich
view that is analogous to our current WPF smart client .   Application is
extensible – allows customers to create their own logic and the application will
pick up custom assembly using reflection and then appropriately invoking the
correct methods.  This feature allows us to leverage the architecture pattern of
a composite application.  Application also allows for recognizing when the server
application sends it a “message” and dynamically shows the user an attractive
“div” with the message.  All of these features help give the application the
appearance of a desktop application.  Application makes heavy use of design
patterns and unit testing.
Architect and lead developer of a high performance stand alone loosely coupled
multi threaded service monitor engine.  This is a C# windows managed service that
listens to MSMQ (which allows us to not have tie the engine to our application
server, and allows other application to communicate with our application server),
iterates over all the items in the collection is sitting in the queue, performs
generic comparisons on the data, and then pushes the compared data over to
another MSMQ or back into the initial queue.  We have proven that we can do over
1 million comparisons every minute for extended periods of time without
degradation of physical server resources.   
Lead Developer of dynamic runtime driven business process framework.  This
framework allows a power user to create custom business rules to fire when one or
many business objects  reach a runtime defined state.  These rules allow runtime
modification of data, messaging, and denial of data modification (transaction
rollback).  All custom processes can be invoked to run within the current
threaded transaction or run in an asynchronous fashion.  This allows for very
complex workflow decisions and automation to be defined on a client by client
basis.   In addition, I also created a WPF tool that allows us to easily manage
these custom business processes, modify our custom client metadata, etc.  
Design and developed licensing strategy.  We created a strategy that allows us
to reasonably be able to a track usage of our software, prevent unauthorized
installations, and encourage purchasing of new licenses.  Our strategy needed to
be flexible and not require our customer's to “phone home”, thusly, we needed to
examine the databases that the license is installed on, create / modify files
locally that we examine upon starting up the server service and make decisions
accordingly.  In addition, I created a WPF application that allows us to monitor
license usage, create licenses and store licenses, track and modify license
tokens, and modify licenses/. 
Developed encryption and code obfuscation strategy.  We needed to be able to
examine information about how the application was behaving, hide our intellectual
property, etc.  We leveraged encryption algorithms found in the .Net framework
and then creatively applied the encryption.  We also obfuscate our distributed
assemblies which helps protect our IP.
Product integration - I created number XSLT maps allowed us to integrate our
server application via our enterprise service bus layer with numerous 3rd party
applications and servers.  I was also responsible for our integration web service
that the enterprise service bus communicated with.  This service was a standard
.Net web service.  In addition, I helped maintain as needed our WCF service that
our smart and web clients communicated with.