Programmer for Hire

Just for show and tell, here’s a tidy example of what web application development prowess can achieve to bring more life and vigor to a project:

http://www.beingawesomeisawesomefest.com/

Being Awesome is Awesome Fest is something I created as part of coaching a leadership program with the folks at Landmark Education.  Using the fantastic design work of Anne Richardson, I took about 2 days to create a website to power the project: user profiles, project submissions, status updates, email communications.

I stood in the office of my clients having just wrapped up a successful quick visit, and gave a strategic, pensive pause.

“So… you guys get a free day.” I said plainly, as though what I meant was perfectly clear and well established.

It wasn’t of course, and immediately aroused the earnest curiosity that I was aiming for.  “What’s that mean?” asked one of my clients, as if right on cue.

“A free day.  Meaning I’ll come into the office at 9am prompt, laptop in hand, and be at your disposal to bang out whatever new features, tweaks, enhancements, or anything else you’d like to add to your system.  My super powers are yours to wield for a full day, no charge.  I totally dig working with you guys, and this is my way of saying thanks for the opportunity.”

(As an aside, let me point out that our working relationship had thus far been 100% based on me assigning dollar amounts to chunks of work (projects, features, enhancements, etc).  Hourly availability was never on the table, as I don’t really believe in that model for the kind of work that I do.  So to have me in the office to perform whatever work I could in a solid 8 hour day was quite the novelty, and a rather valuable one at that.)

“It’s a chance for you to get whatever enhancements or tweaks made to have you really love the system without worrying about the cost.” I went on to explain.  “Having me in house will enable me to quickly identify how you’re using things and what’ll make them even better for you.”  Eyes lit up at the prospect, they were just about to go live with the system for the first time, and having me after a few days of really using things was in their estimation perfect and fortuitous timing.  We picked a day during the following week.

“It’s good form to buy me lunch, during that day.” I said with a smile as I walked out, “Keeps me at my desk working on stuff for longer.  Oh, and for best results I also recommend having a spare monitor available… I can get more done when rockin’ the dual screen.”

The day itself was a hit.  My second monitor as well a USB keyboard (“in case you prefer it to your laptop keyboard) were there and waiting in my conference room setup when I arrived, and the whiteboard was loaded up with a huge list of check box-adorned to-dos.  A spirit of “yay, John’s in the house!” was palpably in the air.  I was well taken care of and lunch ordered in was delicious.

I say this all not to boast, but to point out how the human element can massively work in everyone’s favor in programming.  I’m human, so the excitement that I’m in the house pumps me up, which gives me massive focus and determination to have a rockin’ day, which creates superb results.  Programming at its purpose-filled, invigorated best.

And when 5pm rolled around, what was the net result of this 8-hour generosity?  My client loves their system even more, have gotten massive value out of the programming I did, and appreciates the heck out of me for it.  I walk on air as I leave the office after having the sensation of being a hero for a day, I’m better related to what my clients are trying to accomplish which henceforth makes me a better consultant to them, I’ve got a bunch more billable work to perform to wrap up and extend upon various bits that got done, and I got free lunch.

A day in the life of a programmer well spent.

I had an enjoyable meeting with a peer of web dev wizardry the other week.  He was illustrating a development framework for web apps that he created, talking me through the many layers of the architecture.  While enjoying the discourse there was one small thing that he said that I thought profound: “no one’s a master of the entire [web technology] stack”.  He said it so matter-of-factly, no big deal, just a transition sentence to frame an illustration of the beauty of one smart abstraction or another in his framework.

No one is a master of the entire web tech stack.

(For those of you not familiar with such nerd speak, the “stack” we’re referring to is the several varied technologies, each layered upon the previous, which collectively comprise and power web applications.  Server runs upon operating system, database runs on a server, business logic uses database, and so on.)

No one is a master of the entire web stack. Conventional wisdom.  Self evident.  But of course.

I disagree. My musings in the last few months have led me to curiosity about my staunch opposition to conventional wisdom that [non-trivial] application development requires a large team, large budget, and long time lines: am I full of it?  Is there something I’m missing? Where’s the loophole?

Mastering the entire stack might be that loophole.

(A quick technical caveat for the nerdy purists in the house: I don’t pretend that I’ve mastered the literal entire stack, for example I know only a little about the L in LAMP stack¹.  But since you do things nearly identically on the so-called WAMP stack (swap in Windows for the operating system), I don’t think my craft suffers for it.  This suggests there are some shortcuts one can take while effectively maintaining mastery over the technologies that make a difference when creating web applications.  Similarly, one can get by with only crude [or even zero] knowledge of, say, hardware level logic gates and assembly language, which are also part of the rigorously defined entire stack.)

For this discourse I say the entire web stack that matters in web application development is comprised of: database, server side language, HTML, CSS, JavaScript, and enough knowledge about server software and hardware performance to not be blindsided by rookie mistakes nor dumbfounded by scalability challenges.  That’s it, and there is plenty of depth and mastery in each of these layers.  Regarding this web stack, my friend was approximately right: developers who are masters of it all are super rare².

This I think may be my loophole.  In a world where designations like “database admin”, “front end developer”, and “back end developer” comprise commonplace job titles, it’s obvious that most teams and individuals in my trade are sold on segmentation of skills along slices of the technology stack as the best way to do it.  Specialization and depth over broad, general skill sets.  Makes sense, our civilization has been going in that direction for centuries.

But does it need to be?  It’s certainly not ideal: communication overhead and inflexibility makes it easy for me to best most teams on price, time and quality, I have enough client horror stories to assure me of that.  So then is your average developer stuck in a niche, unable to branch out their mastery because it’s too much to handle?  Am I just a genius?  I don’t think so.

I think above all it’s a matter of just trying.  Overcome that little voice in your head that says “who am I to design a schema without the fancy title of Database Administrator?” and just do it³.  Play with a nice JS framework and make some cool AJAX stuff happen on the client side of things, most of the hard stuff is done for you anyway.  Learn a few CSS tricks and experiment with making things pretty instead of stark utilitarian.  I bet the average pigeon-holed developer could explore in other parts of the stack and be at least baseline proficient in all of it with just a few weeks of dabbling on the side.  It’s those Renaissance-type developers that you really want.

Notes:

I recently had a good sense to add this new boilerplate section to my standard project contracts:

3.5 RIGHT TO DEMAND SATISFACTION

Acceptance of this agreement includes the right to demand satisfaction for all described features, no more, no less.  I’m on the hook to complete all the described features to the point that you love it, and you get to demand satisfaction to that extent.  So do it.  If you’re not happy, and you haven’t exercised this clause, you’re technically in breach of this agreement.  Just sayin’.

In my years of experience I have never been burned putting myself on the hook called “my work is not done until you love it” , so I realized that I may as well get the benefit of advertising as much up front.

I don’t know that this sort of clause exists anywhere else in my industry.  Flippant language aside (which in my estimation is rad: if that sort of playfulness backed up solid performance turns you off, you’re not my client anyway), I think there’s a general fear about having to appease some fictional, nightmare client who is endlessly demanding.  In my experience, when it comes to my world of web programming, they don’t exist¹.  Oh sure, there’s always room to want more features, or a cheaper price, but that’s not what what’s on the table here.

This here is a promise to do great with all of the [meticulously outlined] features within the scope of work at hand.  Software development is generally a complex endeavor so I think the average bear understandably shies away from such a tall promise.  Fair enough.  I embrace it.  It keeps me honest and fosters a healthy pride in my craft, and if I just bring my art to it using my full facility with leading edge technologies and tricks, I don’t have to worry about falling short.

So I don’t fall short.  If my first attempt isn’t loved by my client, they tell me and I tweak accordingly.  No fuss, no muss².

That’s the second beauty of stating up front the right to demand satisfaction: it creates a conversational dynamic between my client and I that deliberately CALLS FOR that kind of feedback.  We become partners in the endeavor to create software that perfectly suits, and they have a role to play called “speak up if you don’t love it.”  When the invitation to do that is clear and on the table it is easy and fun to exercise, and moreover doesn’t get compromised by a desire to be polite.

Notes:

A fair question indeed.

I bill myself as an ultra effective development team of one, citing of course virtues like eliminated communication overhead, a shorter route from business vision to application design and implementation, nimble ability to adapt the application to changing business needs when they come up, and 100% accountability when it comes to turning out quality.

Oh, and it’s cheap to hire one person instead of six.

So naturally it has occurred to my clients on more than one occasion to ask me “what happens if you get hit by a bus?”  If I’m the guy who’s doing it all, naturally I represent a sizable single point of failure.

Here’s my answer.

You replace me.  Though I do have a publicly documented love affair with Classic ASP, Classic ASP developers are a dying breed, so it would be irresponsible to start any new substantial project for a client in that language. No, anything that’s built to last I would start in PHP or perhaps Ruby on Rails, languages that boast thriving communities of developer talent from which you could draw to replace poor old mangled (or dead) me.

Now then, when you replace me my successor will need to be trained on how to work on the code base I’ve laid down.  If I’m NOT dead I can guide them through to get them up to speed quickly.  I if AM dead the good news is that my code is quite beautiful and well organized, with perfectly uniform indentation and formatting, completely consistent conventions, and immaculately well factored.  Any developer who is worth their salt in the language I have laid down will be able to understand, trace, and build upon my code within one day of poring over it.  (If not, fire them.  Trust me.)

Furthermore, whatever I did manage to complete before carelessly failing to look the other way while crossing that hypothetical street will constitute a massive leg up on your project.  Remember, typical development projects tend to be heavily loaded on the front end with meetings, spec docs, planning, project management, and other such things that don’t get you closer to a usable piece of software.  Before that Greyhound sent me to a better place even a half-completed prototype done by me will have enabled you to shortcut through all of that, leaving you with a sensible solution strategy and design foundation already in existence.

So in conclusion: if I get hit by a bus, you replace me.  You’ll miss me as you move forward at not as smooth or fast a clip as before, but your project will have gotten the benefit of my precious last remaining pre-bus-hit days.

It’s kinda like getting Frank Lloyd Wright to draw up the plans for your house and then he can’t finish it.  It’s still gonna be a pretty snazzy house even if some junior architect needs to rough in details like which tiles to use in the bathroom.

I recently quoted $250 in response to a client with a particular feature request.  The reply I got was asking if I could add this feature for $125, citing perfectly good and valid reasons of it not seeming like that much and a desire to keep costs down.

Here is my exact reply:

Nah,

Whenever I let a client name the price I turn into a poor businessman indeed, and it puts me on a slippery slope of devalued self worth trying to please clients who will nickel-and-dime me and don’t really value my time.  Most damaging is that it tends to prevent me from doing the great and interesting things with my talents that I’m committed to doing in this lifetime.

Poetic waxing aside, I have a LOT of real world data that the price I charge for the value I provide is above-average fair and, relative to other vendors, sometimes ridiculously cheap.

Now then on this particular price, I’m not hosing you to make a couple extra bucks as though I were a shoe-in for the work: between transitioning mentally from other projects, sorting out your request, pre-pondering the best solution, doing the coding (which I reckon is what you figure should cost $125, and reasonably so), testing it, launching it, testing it live, being generous with any tweaks/enhancements you might request (has it been your experience that I’m fairly generous with these?  It is my aim that it has, and please let me know if I’ve fallen short!), and the sliver of added complexity that it entails for future maintenance/trouble shooting, I stand by my estimate of 2 hours.

(A common alternative to this is quick, get-er-done style work where one change breaks something else, perhaps familiar to you! :)

That said, you might have noticed that a lot of items in the list of things above represent the overhead of doing a non-trivial amount of work of ANY size, and you would be right to think that that sort of overhead is roughly constant no matter how much substantial work is to be done.  I do my best to have evolving and tweaking a system be as fast, easy and painless as possible (and I understand I do pretty darn good at it relative to my industry), but the general rule still always holds: that we’ll both always get a better value for our time and money the more you can batch feature and change requests together (a full day’s work in my experience is generally the tipping point).

Whatever you think for this one is totally cool by me.  If the day ever comes that you want to transition from me for any reason, be it price or whatever (or in the event that I need to move on myself) I am completely reliable to be 100% cool and helpful in facilitating that transition.  I’ll even train the next guy on the code and be available for quick questions (in the past for clients I really liked I’ve even done this training for free).  I’m committed that you NEVER have the experience that you’re stuck with me when you could do better.

Whew, that’s lot!  I didn’t mean to talk your ear off with the above, and know that I don’t mind your request at all.  Hopefully you’ve gotten some nuggets on how to get the best bang for your buck out of me.

Cheers!
John

Looking back there are a lot of things about this communication that I like.  It is a candid look at how I work with and honor my client relationships that I am happy to share publicly: it gives some insight as to how to get the best value of out me, reveals that a lock-in is NOT part of my business model, and gives the freedom to choose.  Negotiation-wise there are a lot of points made and I want to add a few more to round out the exposé of my thoughts on the matter.

My stance on not negotiating price serves both me and my clients because it keeps me honest and true to my standards.  Coupled with my willingness to facilitate anyone in transitioning to another developer, it holds me to a standard of being the best and giving the grade-A experience of working with me. If I don’t perform at the level I say I do and thereby someone can get a better value with someone else, I will lose that business and I should.  Short-cut jobs with me are simply not on the table, though the option to get one somewhere else is.

Psychological factors play into it as well.  When I know I’ll be earning what I feel I’m worth for a piece of work, it’s easy and a joy to put the shine on it and go the extra mile, and my clients regularly reap the benefit of this.  By contrast, in the past when I’ve allowed myself to get beat up on price I had to fight against the devil on my shoulder telling me that just meeting the spec-doc minimums was acceptable.  I always won, but those then were the clients I eventually fired.

If nothing else, not negotiating on price forces me to work with the right clients.  For a mom-and-pop business looking to get a website online, I’m expensive.  For a million-dollar company for which custom software is an integral part, I’m cheap.  In some cases ridiculously cheap.  So if I’m getting push back on my price, it’s a sign that we’re not a good fit, and acknowledging that sooner than later is useful for both of us.

And in case you were wondering, my rate of $250 was accepted via email reply 14 minutes later.

Here’s an actual email dialog with one of my favoritest clients, identifying bits changed to honor confidentiality:

We have an idea for a SuchAndSuch iPhone app. Can you recommend a great developer?

Yep.

Mother fuckin’ me.

John

That’s what I like to hear. We’ll chat soon.

There’s something great about knowing you are completely qualified to take care of someone’s need, and communicating as much in no uncertain terms.

Classic ASP.  Microsoft’s lofty first vehicle to try and corner the market web application development tools and technologies.  It plateaued in November 2000 with it’s final release version, 3.0, and was superseded by ASP.net in January 2002.

And the world was largely happy to be done with it.

Today, 9 years later, it is by all reasonable accounts a washed up technology.  Any mention you hear of it these days in blogs or tweets is most likely from some poor soul lamenting being saddled with doing maintenance work on a legacy system.

Yet here I am, in 2011, and I find myself oddly capable of doing substantial projects in in still, and it DOESN’T feel like pulling teeth.  Between that and my profound distaste for the new-fangled ASP.net which technically I should love by now, I stopped to wonder why.

It’s true that VBScript, the language that predominantly powers ASP, is a not a great language.  And ASP, with it’s very loose and tumble style of negligible structure and convention, makes possible ridiculously sloppy form.  Its simplicity means a low barrier to entry, so there’s a lot of terrible code out there banged out by highly mediocre programmers.  So ASP as a relatively immature environment got a bad rap for some good reasons.

But that’s all part of why I love it.  Rather than a lot of rules, conventions, strict object oriented paradigms, and so forth that prevent poor programmers from doing terrible things, the wild, wild west nature of little structure makes possible defining your own.  And when you know what you’re doing with that kind of freedom you can mold the language into something that suits your style and the way you think.  While the prevailing wisdom/complaint about Classic ASP is that it takes 9 lines of code to fetch a value from the database, like so:

Dim oConn, rsUsers
Set oConn = Server.CreateObject("ADODB.Connection")
oConn.Open "DRIVER={Microsoft Access Driver (*.mdb)}; DBQ=" & Server.MapPath("DB.mdb")
Set rsUsers = Server.CreateObject("ADODB.Recordset")
rsUsers.Open "SELECT firstName FROM tblUsers WHERE ID=4", oConn,1,3
Dim firstName : firstName = rsUsers("firstName")
Set rsUsers = nothingoConn.Close()
Set oConn = nothing

I find programming remarkably tolerable with some well crafted, low level extensions to the language, which makes my work look more like this:

Dim firstName : firstName = GetDatabaseField("tblUsers", "firstName", 4)

So-called “bottom up” programming is nothing new, but I seldom see it done well in the ASP code of others.  The intersection between people using such an obscure and primitive language and people able enough to lend real ingenuity to a programming environment appears to be pretty sparse.

But that’s just it.

That’s one of the things that I credit my current overall ability of web programming to: I cut my teeth on classic ASP when it was relevant and did some substantial projects in it, and needing to “roll my own” in a sparse programming environment as opposed to waiting for some .NET package to solve a problem for me has made me intimately familiar with the low level workings of browsers, databases and so on.  Its like training at altitude: make something work in unfavorable conditions, and you can really excel everywhere else.

So here’s to you, classic ASP.  I am a better programmer for your out-of-the-box crudeness, and accordingly you haven’t been that bad to work with anyway.

It is conventional wisdom that software development is complicated.

Triply so if you stick the word “enterprise” in front of it.

By complicated (and complicated x 3 for so-called “enterprise software”) I’m referring to the whole pomp and circumstance that surrounds the actual process of banging out code to solve a problem.  Needs analyzing, requirements gathering, stakeholder interviewing, spec formalizing, story boarding, resource planning, milestone setting, time line estimating¹, wire frame designing, and prototype building are all usually part of the dance, and that’s just the front end.  On the back end you have testing, quality assuring, requirements verifying and acceptance reviewing.  (Here to forth the sum of these activities will be referred to as “the formalities”.)

With so many disparate verbs involved, conventional wisdom accordingly asserts that it takes a team of at least half a dozen highly trained and specialized professionals to pull it off.  This itself gives rise to boatloads of meetings, coordination, consensus gaining, gaps in understanding, and other communication overhead.  The formalities effectively constitute a gatekeeper from a new piece of software getting out into the real world, lest it do something that’s embarrassing, incorrect or otherwise terrible.  So you’re paying the price of all this work before a new software solution actually gets to do you any good in real world use.  (This, incidentally, is how million dollar software gets built that actual users hate.)

Does this model have a place?  Absolutely.  Some projects are sufficiently complex/important/sensitive to justify that kind of slow, methodical approach.  But many aren’t.

One of my roles during my tenure at MonsterCommerce was being in charge of development on the MonsterMarketplace, a shopping portal that aggregated product listings from several thousand of our e-commerce clients.  The building of the MMP was originally outsourced to an international resources development firm, and the [accepted] proposal for the project contained line items of many (costly) hours for the formalities.  It was a sizable system distributed over two web servers, one database server, and tied to its own [then newfangled] Google Search Appliance.  It was a great site and they did a good job.  But l don’t know that we got our money’s worth for all that supposed testing and quality assurance.

Like most sufficiently complicated systems there were bugs, hiccups, gotchas, and performance issues.  Not necessarily glaring ones, but critical none the less.  When new campaigns were launched to drive more traffic the system had to be carefully monitored due to memory leaks and other inefficiencies that would routinely crash a server.  As traffic soared beyond 100,000+ visitors a day such reactive maintenance became the norm.

When I took over maintenance of the system these problems remained for me to solve, and there was also a fresh new look to be implemented.  My calculated path of least resistance was to rewrite the entire front end myself, which was tantamount to breaking many rules of the development cycle and best practices as laid out by the outsource firm.

But it worked.

In 4 weeks I had made the new front end, polished by about a week of collaboration with the sharp-eyed spot checking of my boss.  We launched and watched the CPU usage loads under traffic, which instead of dancing between 20 and 100% utilization like before were scarcely seen above 4%.

How did that happen?  The first version of the MMP was built by a team of people, and subjected to (presumably) all kinds of formal testing and quality assurance. The version I cooked up was written just by me with only the benefit of my boss who loved to click around and see to it that all was well with his brain child.  Granted, I had the benefit of an already laid out foundation for the system, but my aim was much more to rip out and replace that foundation than to bootstrap off of it.

This was a matter of raw ability trumping best practices, both technically and management-wise.  I knew a few things about the lower levels of computer architecture that best practices were apparently oblivious to, so I could get rid of what were (to me) glaring performance problems ².  I was close enough to the vision and intended outcome of the project that I could be trusted to remain true to it.  The objective win of this was the quicker end to hemorrhaging revenues due to sporadic downtime.  The subjective win was the satisfaction my boss felt getting a major release out without all the painful fuss of formalities that plagued the first time around.  (And the win for me was the satisfaction of delivering on what was viewed as a tall and unlikely promise, plus a $7000 raise given to me the day after launch.)

What I’m curious about is how many projects are beholden to the more complex level of rigor out of a false sense that they should be (or need to be) in order to turn out.  In my experience the procedures and complexity of methodical collaboration ultimately become self-justifying: all the brain farts, delays, back-and-forth interactions, and so on make it harder for a quality developer to get actual work done.  It’s then no wonder if he/she can’t be trusted to create a solid end product without micro-management and support.  It’s worth considering that the end quality level is a wash at best, only you spent a lot more time and high salaries to cobble it all together.

Programming at the Speed of Trust

To do away with all the formalities, I assert, is the programming equivalent of Covey’s maxim “The Speed of Trust” ³.  If you have a nimble, self-directed team of developers (even a team of one) that is intimately familiar enough with the aims and needs of a project to do it right, there exists the opportunity to sidestep all of it in favor of trusting them to responsibly do their job.  The reason is that a lot of best practices are above all designed to prevent screw ups rather than promote excellence (having massive amounts of meticulous documentation and following someone elses’ protocols to the letter counts in many ways as a big C.Y.A. and little else).

Cultivating and using this approach to software development needs to be done with care.  No doubt many of our modern practices were born of reactions to past disasters, which leads me to think there’s a largely unrecognized dichotomy in approaches to software: one approach is formality as preemptive damage control, the other is running at the speed of trust.  Nimble start ups by default operate at the latter, and for it have created some of the most amazing software on shoestring budgets and in record time.  Established software development houses and large companies with full blown IT department are almost inextricably married to the former, probably because cultivating the latter doesn’t seem like a viable option with any reliability.

What, then, does it take to cultivate the latter reliably?  I think whomever cracks that code is going to have a major leg up in any business that calls for custom software.  I do know of a couple conditions that help:

• The ability to release early and release often. This is the era of cloud computing and the mobile app, so this isn’t as tall an order as it used to be⁴.  Being able to fix flaws immediately when discovered makes them much less harmful and much more palatable.
• Give developers at least a semi-regular taste of doing the job that the software is supposed to help with. This is important before, during and after development.  Before because it lets them experience exactly what they’re solving for.  During to keep true to what’s important as things progress.  After because a good developer can almost always improve software they’ve made if they’re saddled with using it.
• Break the project into individually useful chunks, and put each chunk to good use as it’s ready. Making a complex uber-system is dangerous business only if you have to finish it up to the very end before getting to experience if it sucks or not.  Structure a project so that the fruits of it are apparent sooner than later, and that the wins of the last release spur on the next one.
• Have a developer experience that it’s their baby. Whether intentional or not, nothing prompts a sense of “get ‘er done and move on to the next one” as when that is precisely how the job is set up.  This makes cutting corners much more likely.  If a developer knows he or she is on board to grow and evolve the system over time, a sense of pride and long term responsibility kicks in that can’t be beat for ensuring quality now.
• Give a developer some form of vested interest in the project’s success. This is similar to the last one, but not quite.  It’s vested interest that strongly evokes above-and-beyond effort and innovation.

I think the formalities are wholly valid, and exist for a lot of good reasons.  However like most things that are seldom questioned it is useful to question their necessity for a given project, simply because the reward is the opportunity to program at the speed of trust.

Notes:

Michael Gerber, in his treatise on entrepreneurship The E-Myth [1], makes a firm point of the dangers of working in your business when you yourself are the entrepreneur trying to run and grow it (i.e. working on your business).  He makes a compelling case that the activities of one and the other are not only completely distinct, but that they are also virtually mutually exclusive.

I completely agree.

It was a watershed moment for me when I acknowledged for myself that am far more interested in being a consultant than building and running a consultancy, even though the the latter carries with it much more prestige.  I love the kind of consulting and application development that I do, and at the same time I have no interest in building a team of me-clones to do contract consulting work.   So when it comes to me as a free agent consultant, I am much more about working in my business than on my business, and Michael Gerber is right to say that I haven’t created a business so much as a job.

The reason this is interesting at all is because of the fun twist on the in-the-business/on-the-business dichotomy that I love to play with: for an application developer who is not afraid to get his/her hands dirty with the daily roles and work of a given business, there is opportunity to make massive improvements to how that work is done.  An example will make this clear.

During my one straight job out of school at MonsterCommerce I held a number of roles and one of them was manager of the custom programming department.  We were an e-commerce company selling an already spiffy, feature-loaded shopping cart software package, but that didn’t stop loads of our customers from wanting it to do more new and novel things.  So we had a custom programming department that would take feature requests, offer quotes for the work, and execute the jobs when opted for.  About 2-4 requests would come in per day.

The system I inherited for managing these leads and projects was a drawer of a few hanging folders, my predecessor’s email in-box, and a notebook or two of notes.  The notebook system, it turns out, scaled maybe for two weeks’ worth of leads before becoming cumbersome and impossible to manage without jobs and tasks slipping through the cracks.  By this firsthand experience of working in the business I knew things could be better, and with programming skills, a desire to learn web programming (new to me then), and a dash of confidence (arrogance? ) I set out to create the solution I knew I wanted.

It was fueled by a simple vision: whenever so-and-so called, I wanted to type their name in, see their job on my screen with the complete lowdown (what they wanted, the status of the job, and even when we last talked and what was said), and be able to talk intelligibly about their project within 10 seconds as if getting it done was the only thing on my mind.  (I think a lot of visions are fueled by frustration of doing something a few times when you know it could be so much better.)

Taking inspiration (and the design aesthetic) from our own shopping cart software, I learned how to program web applications[2] and design databases, and built my dream system one weekend at a time.  It sat there, hosted humbly on the floor within the computer in my bedroom, during a time when each subsequent week a little more of my job was managed or automated by it.

After six weekends of development (and the interim six weeks of real-world use, testing, and tweaking), I was ready to show off my baby to the rest of the company.  It was well received by all the parties it touched upon: billing, sales, management, and my team of programmers, and getting adoption was quick and painless.  (The greatest honor was when the Design and SEO department heads both requested a similar system: I quickly forked off versions to suit both.  The second greatest honor was hearing that it wasn’t until 2009 until these systems were retired, fully 3 years after I left the company.)

Building something that good was made easy (almost trivial, it felt) because I was making it for me to solve my own day-to-day problems.  When my day-to-day usage revealed something that sucked I would simply fix it that night at home, and have a better system the next day.  I had bridged the creator/user gap.

Not only were the systems nice and made a manager’s job easier, it made the departments better.  Communication, coordination, follow through, professionalism and the bottom line all benefited.  It was the stuff of systematizing things that Micheal Gerber would classify as working on the business, and doing so happened because I was steeped a little while working in the business.

This is completely unconventional.  Software development talent seldom experiences the day-to-day work of the people for whom they create software for, yet what if that experience is a shortcut to making a really great system?  Though unorthodox, time spent by a developer actually doing a job for which he/she is to make a software system for may pay out overall in time saved trying to otherwise imagine, describe and communicate the software needs.   Any additional unimagined solutions/shortcuts/innovations devised by the developer-turned-worker are a pleasant bonus.  Furthermore it makes nice protection from rough or ugly spots in an application: if a developer is saddled with using his/her own creation (even if for a little while), they will be apt to smooth over and tidy up such unflattering features.

It may be a loophole to the notion that if you’re working in the business you can’t possibly working on it: insofar as software systems are concerned, at least, a person working the job who is able to design systems to make it easier is leveraging the former to help the latter.

Notes:

[1] It’s been 4 years since I read it, so please pardon any haziness in my recollection of it.

[2] This is the root of my [still persistent] fondness for Classic ASP, an arguably terrible and woefully outdated server side web language.  There’s always something special about your first.