Why Taylor’s Things Builds Software | Ownership, Linux & Control

I did not switch to Linux because I was angry at Microsoft.

Well…

I am a little angry now.

But that came later.

There was no dramatic moment where I slammed a laptop shut and declared:

“That’s it. I’m sticking it to the man.”

What happened was much less dramatic and, in the long run, much more important.

Microsoft’s move away from Windows 10 forced me to start looking closely at something I had taken for granted for years:

Who actually controls the computer sitting on my desk?

Windows 10 reached the end of support on October 14, 2025. Microsoft’s supported path forward became Windows 11, with hardware requirements that include an approved processor, TPM 2.0, UEFI/Secure Boot capability, at least 4GB of RAM and at least 64GB of storage. Microsoft’s own Windows 10 end-of-support guidance explains the transition and the available paths forward.

That transition affected a huge pool of computers that did not suddenly stop functioning just because the support calendar changed.

And it made me start asking questions.

Those questions eventually became much bigger than Windows.

They get to the heart of why we started building our own software.

The computer was still good

This was the part I could not get past.

A computer does not suddenly forget how to compute because a newer operating system comes along.

The processor still processes.

The memory still remembers.

The storage still stores.

The screen still displays things.

A machine can remain perfectly capable of doing the work its owner needs while finding itself on the wrong side of a software company’s supported path.

Microsoft itself says Windows 10 machines continue to function after support ends. What changes is that ordinary security updates, feature updates and technical support are no longer provided unless the user qualifies for an extended-support option.

That distinction mattered to me.

The hardware had not necessarily failed.

The ecosystem around it had moved.

And increasingly, the expected answer was:

Buy something newer.

That did not sit right with me.

I bought this stuff

This is the part that still makes me angry.

I bought the computer.

I paid for software.

I paid for upgrades.

I paid for subscriptions.

I paid for services.

Nobody gave me all of this.

I worked, earned money, handed that money over, and reasonably believed that the things I was paying for were there to serve me.

Then a corporation could change its requirements, licensing, support policy, subscription structure or product strategy and dramatically change my relationship with something I had already paid for.

My reaction was basically:

Excuse me? I bought this.

The hardware is sitting on my desk.

The files are my files.

The work is my work.

The money that paid for all of it came out of my pocket.

Technology advances.

Security requirements change.

Companies cannot support every platform forever.

I understand that.

What bothered me was realizing how little practical control paying for something sometimes gives you.

I had been paying like an owner and living like a tenant

That realization changed the way I looked at technology.

With ordinary physical property, ownership feels much simpler.

If I buy a chair, the chair company does not arrive seven years later and tell me sitting version 11 requires a supported seat cushion.

If I buy a hammer, I do not expect the manufacturer to announce that hammering security has improved and my current handle is no longer eligible.

Computers are obviously more complicated than chairs and hammers.

Software needs maintenance.

Networks require security.

Online services cost money to operate.

But somewhere along the way, the technology industry normalized something strange:

You can spend thousands of dollars building a digital life around yourself while retaining surprisingly little control over what happens to it.

I bought the hardware.

The operating system remained governed by somebody else’s license.

I bought software and watched more and more software turn into subscriptions.

I paid for services whose prices and features could change later.

I stored my own information inside ecosystems governed by rules somebody else could rewrite.

And eventually I realized:

I had been spending money like an owner while increasingly being treated like a tenant.

That realization gets to the heart of why we started building our own software.

My first computer in America made the issue personal

The first computer I was given after moving to America was a Samsung Galaxy Book Go Wi-Fi.

So I have a real attachment to that machine.

It uses a Qualcomm Snapdragon 7c Gen 2 processor with integrated Adreno graphics, LPDDR4X memory and eUFS internal storage. My particular machine has 4GB of RAM. Samsung’s Galaxy Book Go specifications describe the platform and memory/storage configuration.

Now, most people reading that probably do not care what Snapdragon, LPDDR4X or eUFS means.

Here is what matters.

The processor and graphics are part of the integrated platform — effectively fixed rather than normal user-upgradeable desktop components.

The 4GB of RAM is on-board — aka soldered and cannot simply be upgraded by adding or replacing a RAM stick.

The internal eUFS storage is not a normal replaceable desktop or laptop SSD that I can casually swap for a larger one.

So if I decide I need more memory, the obvious answer ought to be:

Add more memory.

Except I cannot.

If I need substantially more internal storage, I cannot just treat the machine like a normal serviceable PC and replace the drive.

If I need a faster processor or better graphics, those are not modular upgrades either.

The machine is essentially the configuration Samsung decided it would be when it left the factory.

Four gigabytes makes the point even better

This is where an important distinction matters.

Windows 11 does not require 8GB of RAM.

Microsoft’s current official minimum is 4GB, according to its Windows 11 system requirements.

So my Galaxy Book Go sits right at that minimum.

That actually makes the ownership problem clearer.

Suppose 4GB technically runs the operating system, but I decide that 8GB would make the machine much more useful for the way I work.

On a serviceable computer, that can be a small upgrade.

Buy some RAM.

Open the machine.

Install it.

Keep going.

On my Galaxy Book Go?

Nope.

The memory is fixed to the board.

I cannot go from 4GB to 8GB.

I cannot decide three years later that my needs changed and upgrade the computer accordingly.

I bought the machine.

But one of the most important decisions affecting how long that machine can comfortably meet my needs was permanently made for me at the factory.

That is exactly the kind of ownership problem I am talking about.

So I switched to Linux

Not as revenge.

Not as a protest.

I needed another way to think about computing.

Linux gave me one.

And something interesting happened.

I stopped treating the operating system as something that simply came with the machine and started treating it as something I could choose.

If one Linux distribution did not fit the hardware or the way I worked, I could try another.

I could choose lighter software for limited hardware.

I could keep more things local.

I could understand more of what the system was doing.

I could replace software I did not like.

I could keep useful hardware useful in ways that did not always depend on one company’s preferred upgrade path.

The biggest change was psychological:

The computer started feeling like mine again.

Not perfectly.

There is no modern computer existing in some magical bubble of total independence.

Firmware exists.

Drivers exist.

Networks exist.

Online services exist.

Third-party infrastructure exists.

But the balance of control had shifted noticeably toward me.

Once you experience that difference, it becomes difficult to stop asking why so much technology is built the other way.

Linux did not make me anti-Microsoft

This distinction matters.

Microsoft is not the villain of this story.

Microsoft made platform decisions based on its own security, compatibility, development and commercial priorities.

I can understand why a company moves its platform forward and still dislike what some of those decisions mean for people who own useful hardware.

Those ideas can coexist.

I did not switch to Linux because I needed an enemy.

I switched because I needed an alternative.

And finding an alternative taught me something I probably would not have learned if everything had simply continued working the way I was accustomed to.

Choice matters.

Ownership matters.

Control matters.

The subscription model made the contradiction even more obvious

Subscriptions make sense for some things.

Servers cost money to operate.

Cloud storage costs money.

Security work costs money.

Ongoing support costs money.

I am not suggesting that a company can provide an ongoing service forever without ongoing revenue.

But subscriptions have also changed our relationship with software.

There was a time when buying a program generally meant installing that copy and continuing to use it.

Now it is increasingly common to pay indefinitely for access.

Stop paying and a feature disappears.

The software may stop functioning the way it did before.

The tool you built your workflow around can move into another pricing tier.

The price can change.

The company can change direction.

And I kept coming back to the same thought:

I paid for this.

At what point did paying stop meaning having meaningful control?

Then I started thinking about something more important than the computer

My data.

That is where this stopped being only about hardware and operating systems.

My documents.

My photographs.

My business records.

My customer information.

My creative work.

My files.

My history.

A computer can be replaced.

Some data cannot.

So I started asking questions I probably should have been asking years earlier.

If my information lives inside somebody else’s ecosystem, can I take it with me?

Can I export it in a useful format?

Can another application open it?

Can I back it up myself?

If I stop paying, what happens?

Can I delete my information?

Do I know what the software is collecting about me?

Can I turn off collection that is not necessary for the software to perform its job?

What happens if the company gets sold?

Changes direction?

Closes a service?

Takes yesterday’s included feature and puts it behind tomorrow’s higher-priced subscription?

Those questions stopped feeling theoretical.

If I created the data, the data belongs to me.

Software started creating the same frustrations everywhere

Once I started looking at technology through that lens, I noticed the same pattern everywhere.

Especially while building businesses.

One tool does this.

Another service does that.

You need a plugin to make the two communicate.

Then apparently another plugin to fix the problem created by the first plugin.

One system has part of your customer information.

Another has another part.

Something that worked yesterday breaks after an update.

A useful tool becomes a subscription.

The subscription gets another tier.

And somehow the one feature you actually need ends up in the tier above the one you already pay for.

Meanwhile, the person trying to run the business has accidentally become an unpaid systems integrator.

I kept asking:

Why does this have to work like this?

And the answer increasingly became:

Maybe it doesn’t.

Frustration often leads to an opportunity.

Sometimes the answer is to build the tool

There is only so much complaining you can do.

Eventually you have a decision.

Accept the limitation.

Find another solution.

Or build the thing you actually need.

That is where our software development comes from.

Not because the world desperately needs another application with our logo on it.

Because we encounter real problems.

We try the available solutions.

We figure out what does not make sense.

We identify what we believe can work better.

And when the opportunity makes sense:

We build the tool we wanted in the first place.

That is how software became a legitimate Taylor’s Things product.

I do not want permanent authority over how you use the products we sell

That is one of the clearest lessons I took from my own experience.

I do not want permanent authority over how you use the products we sell.

If you bought it, the relationship begins with the assumption that the product is there to serve you.

Not that selling it gives us another route to control you.

There will always be practical boundaries.

Licenses exist.

Hosted services have operating costs.

Security issues require changes.

Connected software can depend on infrastructure no individual customer controls.

Those realities are real.

But they do not change the direction of the relationship.

We start from the user.

Not from figuring out how much control we can preserve after somebody has already paid us.

Your computer is not somebody else’s billboard

Your hardware belongs to you.

Your data belongs to you.

And software running on your equipment is there to serve you—not quietly turn your computer into somebody else’s platform.

Or advertising space.

Ahem.

No names necessary.

If I buy a device, install software on it and pay for the services surrounding it, I do not think every unused corner of my attention automatically becomes another monetization opportunity.

A computer is a tool.

My tool.

The software is supposed to help me accomplish something.

That sounds obvious.

Increasingly, it does not always feel obvious.

The ownership standard is simple

The technology side of Taylor’s Things keeps coming back to three things:

I bought the hardware. I should control the hardware.

I paid for the software. It should work for me.

I created the data. The data belongs to me.

That is the technology standard Taylor’s Things is building around.

Not because complete independence from every outside system is realistic.

It is not.

The internet depends on other people’s infrastructure.

Computers contain firmware.

Payment networks have rules.

Hosting companies exist.

Security updates matter.

Connected software sometimes needs remote services.

Practical limitations do not require us to abandon the principle.

The user begins from the position of owner—not product, captive audience or permanent tenant.

Open systems changed my expectations

Linux also introduced me much more deeply to open-source software.

What interested me was not the idea that open source automatically means better.

It does not.

There is terrible open-source software.

There is excellent proprietary software.

The difference that interested me was possibility.

Code can be inspected.

Modified.

Forked.

Maintained by someone else.

A useful project does not necessarily have to disappear because the original creator changes direction.

The customer does not always have to remain completely dependent on one vendor deciding what happens next.

That resilience changes the relationship between creator and user.

It does not eliminate trust.

It gives the user another layer of control.

And once I saw that model working, I started asking why more software could not be built with that kind of user autonomy in mind.

Use what you have applies here too

The funny part is how familiar all of this felt.

Taylor’s Things keeps returning to the same Jamaican instinct:

Use what you have.

Understand it.

See what it can still do.

Then make something useful from it.

That applies to software.

It applies to hardware.

It applies to the way we solve problems.

And it is the reason the technology side of Taylor’s Things does not feel disconnected from everything else we sell.

The raw material changes.

The instinct does not.

This is why software belongs beside crochet and bush tea

At first glance, the store probably looks a little ridiculous.

Software.

Handmade Jamaican crochet.

Herbal infusions.

Soap.

Custom computers.

Global Finds.

What kind of product category is that?

None.

Because Taylor’s Things was never really organized around what something is made from.

It is organized around why it deserves to exist here.

The artisan collection connects Jamaican makers with customers who might otherwise never encounter their work.

VitalLeaves gives Jamaican herbal knowledge another way to travel.

Custom PCs give useful hardware another opportunity to keep working.

Curated Finds point people toward useful things we already believe are worth sharing.

And our software exists because we keep finding situations where the available tools do not give users the combination of usefulness, ownership and control we believe they deserve.

Different products.

Different problems.

Same instinct:

If the existing solution does not make sense, see whether we can build a better one.

Hardware, software and data are one conversation

That is ultimately what Microsoft’s Windows transition forced me to understand.

Hardware ownership without software control only goes so far.

Software control means less if your hardware is designed so you cannot meaningfully change it.

And neither means much if your own information remains trapped somewhere you cannot take it with you.

So the technology philosophy behind Taylor’s Things includes all three:

Hardware you control.

Software that works for you.

Data that belongs to you.

Not as slogans pasted onto a box.

As design decisions.

The closer we can keep our products to those principles, the better.

Getting pushed out opened another door

There is a strange irony in all of this.

I could have simply accepted that the answer to changing technology is always another computer.

Another operating system.

Another subscription.

Another account.

Another ecosystem.

And I probably never would have thought very deeply about any of it.

Instead, the experience made me ask a better question:

Why am I accepting this relationship with technology as the only possible one?

That question led me toward Linux.

Linux led me deeper into open systems.

Building Taylor’s Things exposed more frustrations with existing business software.

Those frustrations became ideas.

The ideas became development.

And development turned software into another thing Taylor’s Things can put into the world.

So I suppose Microsoft deserves a little credit.