My name is Socrates Stamateas, and I run Alpha Painting, a residential painting company in Massachusetts.
PaintCurrent came out of that business.
I didn't set out to build software. I spent years trying to find software that would make the systems I had built for myself unnecessary.
The story actually starts in 1990.
It started with manila folders
When I started, every project had a manila folder.
That folder was the job: estimate information, customer notes, scope, paperwork and whatever else mattered.
It was simple, but the basic idea was already there:
One place where the important information about a project came together.
Then computers arrived, and spreadsheets changed what was possible.
Paper could organize information.
A spreadsheet could calculate it.
Hours. Budgets. Revenue. Labor. Production rates. Overhead. Profitability.
Now I could ask questions across the company instead of simply opening one project folder.
How many hours did we estimate? How many did we actually use? What were we producing per hour? What was labor costing us? Were the jobs making money? Was the company making money?
But the spreadsheet still lived on a computer.
And I wasn't running Alpha Painting from behind a desk.
Then the spreadsheet became mobile
That changed when I started running Excel on a Pocket PC.
A Pocket PC was essentially a handheld computer — something that acted a lot like a smartphone before smartphones became part of everyday life.
By 2006, I could carry my spreadsheets into the field.
That was a major breakthrough.
Not because the calculations changed.
The breakthrough was that the information could travel with me.
I could have it at a job, between estimates, or wherever I happened to be while running the company.
The spreadsheets weren't elegant.
But they were answering questions nothing else was answering.
Then SaaS changed my expectations
Eventually I was using Excel on an iPad, and mobility was no longer the problem.
The company's information was now spread across more places.
Estimating. Payroll. Banking. Expenses. Employee hours. Materials. Customer payments.
The next problem was getting all of those pieces to form one current operating picture.
For a long time, I simply accepted the spreadsheets as part of running the company.
That changed roughly 10 years ago as serious contractor SaaS started becoming much more capable.
Products like Jobber, PaintScout and Workglue showed me how far contractor software had come.
Jobber represented the broader home-service SaaS world becoming much more complete.
PaintScout became one of the tools I actually kept because it solved estimating and sales well.
Workglue showed how far a serious operational platform could go in organizing jobs, people and workflows.
Every time a promising product appeared, I had the same thought:
Maybe this is finally the one that lets me get rid of the spreadsheets.
And the better the software became, the stronger that expectation became.
Yet the spreadsheets kept surviving.
Eventually I understood why.
The problem wasn't that the new software couldn't do more than my spreadsheets. It could. The problem was that it still wasn't giving me the particular operating answers I had built the spreadsheets to produce.
Good software didn't necessarily need to be replaced
PaintScout changed the way I thought about this.
It solved estimating and sales well.
I liked it. I wanted to keep it.
That made me realize that maybe I had been asking the wrong question.
I didn't necessarily need one giant system to replace everything.
If PaintScout was good at estimating, keep PaintScout.
If the payroll company was good at payroll, keep the payroll company.
If the bank was good at banking, keep the bank.
If the accountant was good at accounting and tax work, keep the accountant.
Maybe the better principle was:
Keep the tools that work. Solve what is still missing.
What was still missing for me was the current financial and operating picture.
What was payroll actually costing? What did employer burden add? How much labor was productive? What were we producing per hour? What was our real overhead per production hour? What were the jobs actually making? What had been collected and paid? Did the financial activity reconcile to the cash that was really there?
The information existed.
I still had to assemble the answer.
Workglue helped clarify the distinction
Workglue is a great product.
If Alpha Painting grows into a more complex organization with additional management and operational needs, I could see considering a platform like it.
At our current size, though, I don't need all of those features. Keeping more of the workflow in one system keeps things integrated and simple.
It also helped clarify an important distinction.
Managing jobs, employees and workflows is one problem.
Continuously turning production, payroll, burden and company overhead into the numbers I use to manage the business is another.
Even if I eventually adopted a larger operational platform, I would still want that financial and job-costing layer connected to it.
The operating tools may change as a company grows. The need for the financial operating picture does not.
Then I learned the solution could be custom-built
Eventually I realized the thing I wanted was technically possible.
I explored having it built in Airtable.
I spoke with a consulting company that specialized in Airtable implementations for painting contractors. They understood what I was trying to accomplish and could build it.
The problem was the economics.
The initial setup cost and ongoing maintenance cost were out of proportion to the size of my company.
The consulting company acknowledged that too.
At the other end of the market were companies such as Dapt, demonstrating that sophisticated integrations could connect payroll, accounting, time and project systems and create the kind of reporting and job-costing environment I was looking for.
That clarified the gap:
The technology existed. The economics didn't.
I wanted the result of a custom operating system without turning Alpha Painting into a permanent custom-software project.
The math was never the hard part
True overhead per production hour is a good example.
The formula is simple.
Actual overhead divided by actual production hours.
Excel could always calculate it.
The difficult part was keeping everything underneath that calculation current: actual payroll, employer burden, production and non-production hours, salaries, expenses, materials, subcontractors and the correct number of real production hours.
The calculation was easy.
Keeping the inputs current enough to trust the calculation was the work.
My spreadsheets could almost always tell me what had happened.
Eventually.
Once a year was easy.
Once a month was possible.
Once a week was far more useful, but it took more work.
The more current I wanted the information, the more time I had to spend rebuilding it.
I was running Alpha Painting and then spending more time reconstructing Alpha Painting just to understand what had happened while I was running it.
I wanted both.
I wanted to run the company and know what was happening inside it while I was running it.
That is what I now call:
Complete Current Visibility
Eventually I stopped waiting
For years, I assumed someone else would build what I was looking for.
Better computers came.
Then mobile devices.
Then cloud software.
Then contractor SaaS.
Then integrations.
Then configurable platforms and custom integration companies.
Each step got closer.
But the solution I wanted still wasn't available in a form that made sense for Alpha Painting.
So eventually I stopped waiting.
I built it for my own company.
That became PaintCurrent.
From a manila folder to PaintCurrent
Looking back, the progression is simple.
In 1990, I needed organization.
Computers gave me calculation.
The Pocket PC gave me mobility.
Later technology gave me sharing.
Modern software gave me connection.
And eventually I realized what I had been trying to achieve through all of those stages was visibility.
Not after rebuilding the numbers.
Not next month.
Current enough to run the company from.
Information → Calculation → Mobility → Sharing → Connection → Visibility.
PaintCurrent grew directly out of Alpha Painting and the systems I developed while running it.
I didn't build PaintCurrent because spreadsheets couldn't calculate the answers.
I built PaintCurrent because I got tired of doing all the work required to find out what was happening in my own painting company.