My goal is to bring experience, maturity, focus, knowledge, and a healthy amount of hubris to my job in order to tackle both technological and personal challenges.
I am passionate about doing things right and doing them quickly. These are not antithetical; a proper knowledge of principles, action in the face of ambiguity, and diplomacy to coax the best from all can nurture a self-organized software team.
Above all I want to invest in people I believe in and promote a company that I know represents my values.
APPENDTO INC. | Architect/Project Lead, October 2012 – Present
In my current position at appendTo, I have worked on a number of customer projects for the Solutions Delivery department, as well as several projects for internal development.
Web application for managing bulk food donations (customer)
- Functioned as technical lead for this project, and sole developer.
- Deconstructed client needs into user stories.
- Formulated and documented technical architecture, components, and strategies for mitigating technical challenges.
- Worked closely with customer's development team to identify APIs, define data schemas, and document workflows, business requirements, and domain knowledge.
- Created a custom, single-page, responsive web application to replace a legacy line-of-business web application.
- Application worked across mobile devices (primary use case) and modern desktop browsers.
- If offline, application continued to function by combining ApplicationCache and offline storage.
- Application aggressively cached certain HTTP responses so that if offline, those responses could be used as reference for future requests.
- If users submitted delivery forms while offline, submissions were queued and application would process them when network became available.
- Application supported multiple languages through custom localization implementation (included server responses).
- Data access layer implemented with an extensible, promise-based middleware layer to give customer granular control over what happens to requests and responses.
- All data requests abstracted into resource modules.
- Offline support, response caching, request interception, and API authentication error handling implemented as promise-based middleware.
- Used a 5-fold approach to determining online/offline state that degraded across browsers.
- Automatic cache cleanup after configured TTL.
- Interfaced with camera on mobile devices to scan and decode QR codes.
- Custom node.js proxy used to simulate API responses before client implementation was complete, and to proxy requests to finished client APIs, handling authentication, custom headers, virtual application root, etc.
- Build process minified and concatenated all application resources, generated manifest.appcache, and organized assets to be deployed seamlessly on the customer's IIS web server.
Social web application for entrepreneurs (customer)
- Functioned as technical lead for this project.
- Performed initial technical discovery on customer needs.
- Deconstructed customer requirements into user stories and documented technical architecture.
- Managed all project artifacts and kept notes on all meetings and customer interactions for reference.
- Assessed risks and made decisions in cases of ambiguity, keeping team on-task and progressing while balancing potential retrogressions and accounting for potential misdirection.
- Created a scalable, social network web portal for budding entrepreneurs.
- Multi-page web application that tracks personal and professional information of entrepreneurs from all over the U.S.
- User information is combined with a suite of business rules to suggest potential partners for entrepreneurial ventures.
- Members can submit written business articles which is then disseminated to third-party syndication sources.
- Members may find other members in close proximity by using geolocation matching based on zip code and/or latitude and longitude.
- Application client implemented as a multi-page, responsive solution with knockout and jQuery.
- Heavy use of knockout view models for separation of UI, data, and logic concerns.
- Full responsive functionality available across devices and desktop browsers.
- UI enhancements (animations, WYSIWYG editors, form control widgets, etc.) implemented where necessary.
- Application backend implemented as node.js express application server.
- User authentication through customer OAuth2 server using passport.
- Member data stored in mongo replication set, migrated from WordPress MySQL instance.
- Integration with Infusionsoft CRM system via node wrapper around web APIs.
- MongoDB geolocation API leveraged for user proximity lookups.
- Chat servers created with node.js using redis for message routing, but never deployed to production.
- Application server deployed on custom dotCloud instance.
- Custom build and deploy scripts required due to specific custom application requirements.
- Mongo instance deployed to mongolabs.
- Custom migration system developed to transform, clean, merge, and export existing data from both WordPress and Infusionsoft to mongodb.
Web application to connect former military personel with employers (customer)
- Deconstructed high-level application description and wireframes into workable user stories.
- Identified actors, actions, and goals for each story.
- Broke stories down into logical tasks and identified technical requirements for each task.
- Linked all stories back to customer project management system for traceability and acceptance criteria.
- Worked with customer's development team to understand and define common data and components.
- Created a custom single-page web application that connects former military personnel with potential employment opportunities.
- Members could search for jobs offered by various companies based on keywords, company size, industry, etc.
- Members could contact recruiters for companies about specific jobs, or link to external applications.
- Members could favorite specific jobs to visit later.
- Recruiters could track applicants and send messages to potential employment prospects.
- Recruiters could join scheduled job fairs in which members would shop around for employment opportunities.
- Application implemented as a single-page, angular.js client.
- URL routing handled by UI state router, allowing us to divide the application into logical modules (templates and controllers), each of which would be instantiated when its route was invoked.
- Mocked extensive data sets while ioStudio prepared live APIs with specified data schemas.
- Tested all application controllers extensively with mocha/chai and angular's built-in testing facilities.
- Created custom directives for re-usable components (multi-field form elements, background file uploads, etc.).
- Leveraged angular resources for all data access, encapsulating URLs and standardizing data access interfaces.
- Made extensive use of promises for application control flow.
Social web application for teachers and students in academic settings (customer)
- Primarily added features to and extended the functionality of the Manhattan social networking platform with modules that spanned client and server.
- Students and participated in virtual "classes".
- Each user dashboard maintained real-time list of updates (streams) from friends and teachers.
- Real-time changes to user profile information reflected immediately for friends viewing their information.
- Real-time class membership reflected immediately when users were added/removed from a class.
- Users could post a variety of information (text, images, videos) to personal "streams" that would then be added to followers' streams.
- Users with accessibility screen reader requirements supported via aria tags and attributes.
- Application implemented as a single-page Backbone app with a custom data layer that used an in-memory message bus (postal.js) for data requests and application events.
- Finite state machines (machina.js) used to detect network and application state and cache requests and events until states changed.
- node.js used to proxy requests to eCollege Java web services, as well as store application preferences and state data in distributed mongo instances.
- redis used to route event data between application instances. Application servers (node.js) forwarded redis events to browser clients via socket.io.
Web application for members to share annotations on classic texts (customer)
- Analyzed customer issue and performed code review to form initial strategy.
- Documented all bugs, potential risks, and potential solutions.
- Kept tight feedback cycle with client, delivering fixes quickly to meet client deadlines.
- Modified an existing application to solve severe performance problems:
- hundreds to thousands of text ranges created in a document on page load;
- one tooltip per annotation appended to DOM, further causing performance degradation;
- user unable to scroll or interact with the page while annotations loading.
- Determined that ranges were being created using start of document as offset point; dividing the document into logical sections and offsetting ranges from each section improved performance dramatically.
- Interrupted range creation during mouse/keyboard events to make page responsive to the user.
Web application for executing project test suites across browsers (internal)
- Fixed bugs and issues in base strider code (open source project on which BrowserSwarm was built) to meet a looming deadline.
- Executed well under pressure, fixed all known bugs and issues, and identified potential future problems.
- Project launched successfully due to significant last-minute team effort.
- Wrote several technical articles for appendTo blog.
- Led initiative to create a "Modern Web" eBook composed of chapters by appendTo employees
- Contributed several open source projects to a2labs.
- Mentored other developers through one-on-one video chats.
ELSEVIER | Senior Developer, January 2012 – October 2012
- For each application developed I worked closely with business sponsors and team leaders to generate requirements, user stories, and technical designs.
- Some of our UIs made use of Twitter Bootstrap, so I developed an open-source, reusable tree control that could consume arbitrary JSON objects and turn them into a navigable UI. Custom tree events could then be handled in external code as the tree was manipulated. I used this to create a prototype for a proof-of-concept web IDE, where a JSON object with file references would be loaded into the tree, and when a user interacted with each file reference it would load the file from the platform into a tabbed text editor.
- I created a custom piece of strata middleware that intercepted upstream requests and determined which data source should be used to fulfill the request based on the path information that strata provided. This allowed the platform to dynamically “mount” data stores to URL segments as needed, and gave calling code a uniform API for data (instead of having to know about each data store independently).
- I conducted extensive research and gave presentations on topics of import to the project, such as UI libraries, cross-domain iframe communication and browser sandboxing, user experience recommendations about how and when to save data in a user interface, etc.
- Performed project maintenance tasks such as building automated jake tasks, managing and updating NPM packages, rebuilding binary dependencies, filling out unit test suites (mocha/chai), breaking up large node modules into smaller modules for maintainability, creating README files for modules and apps, adding documentation to the wiki, etc.
FPWEB.NET | Senior .NET Developer, December 2010 – January 2012
- In an effort to save time for the engineering team, reduce the cost of setting up a shared SharePoint instance, and provide customers with much quicker service, I consolidate the shared hosting site setup functionality and automated the basic setup process. Engineers would typically use a number of PowerShell scripts that would be executed manually in response to a customer order. I deconstructed the scripts and divided them into functional parts, then used the .NET PowerShell libraries to automate their execution in response to orders placed on our public website. My solution was highly extensible: each step in the provisioning process was encapsulated and placed in an execution pipeline, the inputs of which were the outputs of the preceding steps. The solution was designed so that additional provisioning functionality could be inserted into the pipeline by extending existing classes.
- I was also responsible for handling specific portions of the data migration strategy, specifically being able to synchronize product price changes made in local systems to our billing provider remotely, in bulk. This allowed management to bypass the inherent limitations of the billing provider’s user interface and edit the prices of multiple items at once. Also, because our products were informally categorized in hierarchical relationships (informal because the billing provider’s system did not support such relationships), it was necessary to propagate price changes through a hierarchy of products, allowing management to change the price of the “topmost” product–a change that would be replicated throughout the tree. I created a command line utility that would perform these operations based on price changes that management would specify.
- To eliminate the rigidity of our existing billing system (an IBM AS400), and to give management the flexibility to define products and services in ways that allow us to accommodate a variety of customers and their specific hosting needs, our team migrated all existing billing information from our legacy system to a cloud billing provider. I was primarily responsible for creating a data sync solution that would pull data from the cloud billing provider and store it in an on-site data store for disaster recovery purposes, reporting, and to be accessed by internal applications. My solution used the WSDL endpoints provided by the billing provider, as well as their CSV-based reporting interface to consolidate data from the billing system, and write it to our internal data store. The synchronization service used several threads to run different synchronization schedules (an incremental synchronization every fifteen minutes, and a full synchronization once a day). Each thread communicated its status to the other so that two synchronizations would never happen simultaneously. The software was installed as a Windows service, but could also be run ad-hoc as a command line executable. It was also responsible for failing gracefully if particular errors occurred (e.g., unable to communicate with the remote service), and to issue email warnings if it failed for unknown reasons. This service is now indispensable for the company CFO who uses the local data store to generate financial reports that he cannot obtain from the billing provider’s user interface.
- Our company standardized early on the Chrome browser, specifically because of its advanced HTML5 support, but also because it has a robust plugin system that we wanted to leverage. Company employees typically use a variety of systems, some internal, some external. While we do not directly control external systems, we were able to leverage Chrome’s plugin support to “add” features to external systems that otherwise would not be there. I was directly responsible for implementing a universal feedback form on all sites that employees use in their daily work. I created an HTML5 interface and a JSON service that would consume data submitted by the form, then added scripts to our Chrome plugin that would inject the form into specific internal and external web applications. As a result, company employees can now submit bugs or requests to the development team from any web application they use. This feedback is piped to our task management software (AgileZen) via web services, and we are able to review all requests from employees quickly and effectively. This has become a very popular feature.
- I was also responsible for performing maintenance work on all internal applications and our public website. This usually consisted of bug fixes or small feature requests, or integration with other systems so that data could be shared or viewed by specific employees. I also contributed a significant amount of Wiki documentation to our team’s internal knowledge base so that other team members could quickly digest and be productive with code that I had written if they needed to change or enhance it.
LIPPER (THOMPSON REUTERS) | Web Services Developer, July 2010 – November 2010
Technologies: C#, .NET 4.0, Windows Communication Foundation, SOAP, Oracle 10g, Subversion, CruiseControl.NET, MSTest, Bugzilla, Fiddler
- Developed publicly exposed, secure WCF services to fulfill the feature requirements of the Lipper Investment Management desktop application product. Standard XML serialization was used for message contracts to fulfill SOAP 1.1 conformance requirements.
- Worked with Oracle development team and desktop application development team to design services that were efficient, met performance requirements, and adequately encapsulated business rules. Web services also encapsulated communication with other company systems, such as the financial analytics cluster. Because financial data is time-sensitive, stringent performance requirements were followed, and often required services to execute logic that would acquire data on separate threads, consolidate it on the service thread for caching, and then deliver it to the client.
- Designed, implemented, and documented a multi-threaded task registry that could be initialized with any number of “tasks” at application pool startup and run each of them concurrently until the application pool terminated, or the specified timeout for a given task occurred. I created an initial task implementation that would check the analytics cluster endpoints for connectivity, appropriately marking given endpoints as available or unavailable. Services that required connectivity to the analytics cluster would then request available endpoints from the task, and connect as needed. This guaranteed that unavailable endpoints were never accessed.
- Designed, implemented, and documented an XML-based health check monitoring subsystem which would check service connection dependencies and determine if a service was available or offline. Each dependency that implemented the health check contract would, in turn, check its dependencies, and a consolidated report would be returned to the user from the public facing service method.
- Helped maintain a suite of unit/integration tests which were used to verify the performance level of active services, as well as the accuracy of data returned from them. Created new tests when adding new services or significantly altering existing service functionality.
INTELISPEND | Senior Developer, January 2010 – July 2010
Technologies: C#, .NET 2.0, ASP.NET WebForms, .NET Remoting, Subversion, CruiseControl.NET, NUnit, SQL Server 2005
- Worked with a team of developers to upgrade an existing ASP.NET business web application for a critical 2010 release. The delivery deadline was six months, divided into three week iterations. Planned velocity was exceeded every iteration until release to meet product owner needs. Developers participated in every phase of an Agile lifecycle, including iteration planning, daily stand-up meetings, iteration review, etc.
- Contributed to the standardization of CSS layout rules. Converted many legacy table-based pages to CSS layouts to eliminate excessive markup, promote style reusability, and achieve cross-browser consistency.
- Tested all new and converted web pages in IE6, IE7, and IE8 in order to meet client expectations and needs.
- Created new and updated existing ASP.NET template-based server controls that were used in various places throughout the application.
- Updated the data access layer when needed. Created and modified SQL DDL scripts, stored procedures, functions and pre- and post- deployment scripts.
USFIDELIS | Senior Developer, May 2008 – January 2010
Technologies: C#, .NET 3.5, ASP.NET WebForms, ASP.NET MVC, Windows Communication Foundation, Windows Presentation Foundation, LINQ to SQL, Entity Framework, SQL Server 2005/2008, IIS 7, Visual Studio 2008 Team System, Team Foundation Server 2008, Subversion, Team City, MSTest, NUnit, RhinoMocks
As part of the company’s growth strategy, I split the existing corporate website into three distinct websites and augmented the functionality of each. All websites were written leveraging the .NET 3.5 framework.
- I implemented two static mock-ups in ASP.NET MVC and worked with the design team to make sure web standards were followed. Functionality from the primary corporate site was migrated to each secondary site, respectively.
- I wrote numerous Windows Communication Foundation web services to form an application tier which masked the underlying application data model. Each website consumed WCF services directly.
- I created a data model for each website in TSQL and used LINQ to SQL as the object-relational-mapping tool to interact with the data store.
- I added NUnit unit tests to each secondary site and used RhinoMocks to simulate application dependency functionality in each unit test. A Team City build server was deployed for continuous integration, and unit tests were executed for every source control checkin.
- To bring additional revenue to the company, I finished the re-design and implementation of the primary corporate site and worked with marketing on several web traffic campaigns using Google Web Analytics and Frontline Analytics. I also ensured that all regulatory compliance tasks were implemented in a timely manner.
- I re-factored the primary corporate site to eliminate code duplication, break up dependencies, and ease the maintenance process.
- I worked closely with the application administrator to clean up old environments and implement a standardized promotion process whereby each website was thoroughly tested in internal and external environments before being released. Each environment (development, staging, and production) consisted of a single IIS 7 web server, load balanced IIS 7 web service application servers, and a replicated SQL Server 2008 instance.
- To promote consistent release schedules, I worked with the project manager to re-factor Team Foundation Server source control and develop a change management process. We decided to use a semi-agile approach with small iterations and quick feedback.
In order to mitigate the technological risks of re-engineering the existing line-of-business application, I was assigned to research, prototype, and make recommendations about chosen core technologies.
- Windows Communication Foundation (WCF) – I demonstrated that WCF proxies could be constructed dynamically by wrapping WCF’s ChannelFactory
.Create() call in a custom class that acquired all endpoint settings from a custom data store. I also documented all WCF binding settings that directly affected our environment(s) for quick reference. In addition, I was tasked to demonstrate how clients could receive WCF messages on parallel threads and marshal those messages to the UI thread when UI updates were required.
- LINQ to Entities – After evaluating LINQ to Entities 3.5 and concluding that lack of POCO support, customizable entities, and self-tracking entities (in a disconnected state) were severe hindrances to our project, I began evaluating LINQ to Entities 4.0 beta. I created a proof-of-concept project that demonstrated the new T4 entity templating engine with customized entity templates, and self-tracking entities across a WCF service boundary. Problems with entity object graphs and maintaining entity state after database writes led me to conclude that additional ORM research was warranted because LINQ to Entities is not sufficiently mature.
- Windows Presentation Foundation (WPF) – I evaluated several possible design approaches for WPF user interface views, including Model-View-ViewModel (MVVM) and the Prism framework. We decided to use Prism due to its compatibility with Silverlight, it’s robust EventAggregator messaging system, it’s use of Microsoft’s Unity Application Block for dependency injection, and it’s support for reusable UI regions. I also demonstrated that WPF can enforce action-level security through its commanding system and control-level security through its visual and logical tree helpers.
- log4net – I demonstrated the robust logging capabilities of log4net by creating a custom WCF appender class that sent log messages to a WCF service asynchronously. Since our client applications live in a disconnected state, this will provide a tremendous benefit to developers who will no longer need to ask users to provide physical log files for debugging purposes.
- ININ ICELib – I evaluated ININ’s .NET API for their VOIP telephony system in order to determine if we could integrate call center functionality into our applications without using ININ’s standard client. I was able to connect to the server and perform all basic telephony tasks from within a WPF test harness.
As part of the project leadership team, I took the initiative and wrote several standards documents for the team to consume.
- Coding Standards – Our coding standards document details mechanics of good variable naming conventions, commenting code, exception handling, etc., as well as best practice guidelines for refactoring, .NET Framework usage, event handling, etc. Coding standards were routinely invoked in code reviews to ensure that all developers were consistent in their practices.
- Solution Structure and Namespacing – In order to enforce consistency in Visual Studio solution/project organization, I created this standards document with code organization guidelines. All new projects adhered to its general recommendations.
- Source Control Structure and Branching Strategy – This document was developed in conjunction with our iteration plans to ensure that teams were working in appropriate source branches during development phases. All .NET library dependencies and database were moved into source control as well.
- Performed maintenance work on an existing legacy line-of-business application in preparation for a critical re-write
- Participated in numerous requirements gathering focus group sessions, as well as executive-level steering committee meetings to determine the shortfalls of the existing line of business application and triage feature requests
- Prepared initial documentation for new application architecture, focusing on the business domain and key functional specifications (artifacts included UML diagrams, risk assessments, a vision document, an integration document, etc.)
- Led a design patterns workgroup for existing developers to help educate and empower the development team in preparation for development on the new application
- Contacted third-party data and service vendors and analyzed external APIs in preparation for application integration
BITMESA, LLC. | Partner, March 2008 – December 2010
Huntleigh USA (Client)
Technologies: C#, .NET 3.5, WinForms, Apache, MySQL 5, Subversion, Mantis
- Developed a .NET desktop application to record and manage scheduled wheelchair assistance for over twenty airports in the United States. The application was written in .NET 3.5 WinForms with a custom MySQL data access layer that communicated across a company VPN.
- I implemented an XML based caching module that saved data to a local machine if network connectivity was interrupted, or VPN access was unavailable.
- Custom reports were created in PHP to track individual airport team statistics.
Technologies: C#, .NET 3.5/4.0, ASP.NET, SQL Server 2008, NHibernate, jQuery
- Designed a custom e-commerce retail website for selling apparel online
- Designed a custom database schema for products, sales, customer management, etc.
- Integrated with Authorize.net merchant solutions for e-commerce transactions
- Initially designed the site in standard ASP.NET but migrated later to ASP.NET MVC with NHibernate to increase maintainability and flexibility
FAMILY TREE DNA | Lead Developer, September 2007 – May 2008
Technologies: C#, ASP.NET, SQL Server 2005, IIS 6, Mantis, Subversion
- Assessed business needs that were unfulfilled by existing public-facing website
- Documented existing business practices, and prepared suggestions detailing a software/hardware platform transition
- Established a bug tracking system and trained customer service representatives to use it
- Successfully resolved/fixed 217 of 293 reported bugs €“ roughly a 74% bug closure rate, averaging one bug closed every three hours, every business day from August to November
- Mitigated two separate system intrusion incidents, preserving all data and creating a security solution to prevent further compromises
- Delivered two iterations of upgrades to the site, coordinating with a remote team in China to integrate and deliver changes seamlessly; both upgrades were delivered on-time
Technologies: PHP5, symfony, MySQL 5, Apache, Linux, Mantis, Subversion
- Developed data model, business logic, and user interface components according to business criteria
- Determined priority of requirements and worked in iterative phases to meet deadlines.
- Worked with scientific collaborators in New York, Israel, and the United Kingdom to acquire domain knowledge
- Reviewed several PHP MVC frameworks and chose to develop the application using Symfony due to flexibility, community support, feature availability and documentation
- Developed an XML-based, Schema enforced data exchange with a partner lab in the United Kingdom to deliver order information, and receive testing results, on a regular basis
- Made significant enhancements to the public-facing checkout system, including a dynamic, client-controlled discount and coupon scheme
- Created dynamic PDF reports accessible via the customer portal to give customers access to their test results
- Integrated a third-party appointment tracking system to allow customers to schedule phone calls with in-house genetic counselors
NATIONAL AUTO WARRANTY SERVICES (USFIDELIS) | Software Engineer, August 2006 – August 2007
Technologies: C#, .NET 3.x, WinForms, Windows Communication Foundation, Visual Studio 2005/2008 Team System, Team Foundation Server 2005/2008, Visual Source Safe
- Worked with a team of ten developers on an extensive Lotus Notes legacy system re-platform
- Gathered business rules and scenarios for several administrative departments to determine the appropriate functional and non-functional requirements for the replacement application
- Prepared high level documentation for company business scenarios
- Worked with the database administrator to form a data model consistent with the business model
- Implemented a C# .NET smart client (WinForms and web services) architecture using Microsoft Windows Communication Foundation for a 300+ user call center
- Designed and write a significant portion of the customer service and contract fulfillment portions of the application, as well as the underlying web service components
- Designed and wrote administrative portions of the application used for entering automotive data, team information, and pricing configurations
- Acted as a liaison between the primary application team and the accounting subsystem development team as a reference for the financial operations of the business
- Led a refactoring initiative for core components of the application that underperformed due to fluid requirements
RIVER CITY INTERNET GROUP | Web Application Developer, November 2005 – August 2006
Technologies: PHP 5, Java, Apache, Apache Tomcat, Linux, MySQL 4, Bugzilla, Subversion, Zend Studio
- Worked in collaborative software development environment on an enterprise scale ISP management system IntraISP
- Acted as production support liaison between RCIG and clients by analyzing critical production bugs (both code and data), proposing solutions, and conducting follow-up meetings with clients
- Designed and coded software solutions in accordance with client requirements
- Performed bug analysis and implemented bug fixes for all parts of the IntraISP system, including customer registration and management, equipment activation, customer billing, financial reports, feature management, external/internal APIs, etc.
- Wrote custom software modules to extend PHP front-end functionality and PHP APIs
- Enhanced existing Java web services; performed troubleshooting for Java web service bugs
- Wrote high level and functional documentation according to customer specifications, as well as release notes and test cases for all implemented solutions
- Authored company-wide PHP coding standards document
- Wrote an internal PHP application that tracked software release notes
DSDIRECT (USFIDELIS) | Web Application Developer, July 2005 – October 2005
Technologies: C#, VB.NET, IIS 6, SQL Server 2000, Visual Studio 2003
- Performed requirements analysis for administration projects
- Designed portions of intranet sales application for auto warranty salesmen using ASP.NET (both VB.NET and C# as code-behind languages), Microsoft IIS, and Microsoft SQL Server 2000
- Wrote sales interface documentation
PROTECH NETWORK DESIGN | Web Developer, May 2004 – July 2005
Technologies: PHP 4/5, MySQL 4/5, Apache, Linux, FreeBSD, Zend Studio
- Acted as project manager and web application architect for numerous small/medium-sized businesses clients and individuals
- Performed requirements analysis, prepared sitemaps and cost quotes, and wrote documentation for web projects
- Designed, coded, and maintained a variety of websites and web applications
- Designed and coded internal web application that managed project information, customer information, purchase orders, credit card information, web hosting information, and generated a variety of reports
- Developed several PHP classes (security implementation, calendar) that were re-used in a variety of PHP applications
- Helped administrate a mixed network environment with Windows 2000 and FreeBSD servers
- Performed network installs, cabling, and testing; performed PC troubleshooting, maintenance, and upgrades for client computers
Contact me for a list of references.