Why Texas 67 Systems Runs on Docker and Open Source

When most people think about business technology, they think about big software companies, monthly fees, and tools they do not fully control. I wanted something different for Texas 67 Systems. I wanted tools that are flexible, practical, and built to last. That is one reason I use Docker and open source software.

If those words sound technical, that is okay. They are not as scary as they seem.

Docker is a way to package software so it can run the same way almost anywhere. Think of it like putting an app inside its own tool box. That tool box holds what the app needs so it does not break just because one server is set up a little differently than another. Docker calls these tool boxes “containers.” That matters because it saves time, lowers mistakes, and makes updates easier to manage. Instead of rebuilding a whole server every time I want to test or deploy a service, I can start the right container and get to work. Docker’s own documentation explains that containers help separate apps from the underlying infrastructure and make delivery faster and more consistent.

What Open Source Means

Open source software is software whose code is open for people to inspect, improve, and share under approved licenses. The Open Source Initiative helps define what counts as open source and why that matters. In simple terms, open source gives users more freedom and more visibility. You are not just renting a black box and hoping the vendor always does the right thing. You can see what is being built, follow the project’s progress, and often host it yourself.

For a business, that can be a big deal.

First, open source can help control costs. Many tools still require time, hosting, setup, and support, but you are often not locked into high per-user license fees just to get started. Second, it gives you more control over your own data. That matters to any business that handles client work, documents, passwords, schedules, projects, or websites. Third, it creates flexibility. If one tool no longer fits, you often have a better chance of exporting your data and moving on without starting over from scratch.

There is also a trust factor. Open source is not perfect, and it does not magically make software safe. But it does allow a community to inspect, test, and improve the software over time. That openness can lead to better long-term confidence, especially when paired with good backups, strong passwords, updates, and careful system management.

Why This Matters at Texas 67 Systems

That is the heart of why I built this environment the way I did.

Texas 67 Systems uses Docker to keep services organized and easier to manage. It uses open source tools to build a stack that is practical, flexible, and owned by the business instead of borrowed from someone else’s cloud by default. Some of these tools help with operations. Some help with communication. Some help with security. Some help with websites, documents, notes, or scheduling. Each one solves a real problem.

Here are the main services I am running, or planning to run, for Texas 67 Systems.

• Authentik for identity and access
• Gitea for code hosting and development work
• Invoice Ninja for invoicing and billing
• ERPNext for business management
• Snipe-IT for inventory and asset tracking
• Documenso for signed documents
• OpenArchiver for archived records
• Paperless-ngx for searchable document management
• RustDesk and MeshCentral for remote access and support
• Rybbit Analytics for analytics
• Synapse for team chat and communication
• UniFi Network Application for network management
• WordPress and MainWP for websites and site management
• Vaultwarden for password management
• cloudflared for secure connectivity and publishing
• Stirling PDF for PDF tools
• Node-RED for automation
• Nextcloud for calendar integration, chat, and meetings
• Joplin for notes and documentation
• Posterr for media room and theater display ideas
• Easy!Appointments as a planned scheduling tool

For identity and access, I use Authentik. In plain language, that helps manage sign-in and access across services. Instead of every app living on its own little island, identity tools help bring order to the login process.

For source control and development work, I use Gitea. Gitea describes itself as a self-hosted software development service with Git hosting, code review, collaboration, package support, and CI/CD features. That makes it a strong fit for keeping code, changes, and project history in one place.

For invoicing and billing, I use Invoice Ninja. For business management and ERP needs, I use ERPNext, which is built to handle things like accounting, CRM, projects, asset management, and more. These kinds of tools matter because businesses run on more than good ideas. They run on records, follow-through, and clear systems.

For inventory and asset tracking, I use Snipe-IT. For signed documents, I use Documenso. For archived records, I use OpenArchiver. For document management, I use Paperless-ngx, which turns paper files into a searchable digital archive. Paperless is especially exciting because paperwork has a way of spreading everywhere unless there is one clear home for it.

For remote support and remote access, I use RustDesk and MeshCentral. These tools help support devices without needing to be physically present. That makes support work faster and more practical.

For analytics, I use Rybbit Analytics. For chat and communication, I use Synapse, the server behind Matrix-based messaging. For network management, I use the UniFi Network Application. For websites, I use WordPress and MainWP. WordPress helps power sites, while MainWP can help manage multiple WordPress installs from one place.

For password management, I use Vaultwarden. A password manager is one of the simplest security upgrades a business can make. Strong passwords are hard to manage by memory alone, and reusing passwords is risky. A secure password manager helps reduce that risk.

For secure publishing and connectivity, I use cloudflared. For PDFs, I use Stirling PDF, which offers a wide set of self-hosted PDF tools. For automation, I use Node-RED, a low-code flow-based tool used to collect, transform, and automate data and tasks. Automation may sound fancy, but often it just means saving time by letting the system handle repeatable work.

I also want to include Nextcloud and Joplin in this series because they are part of how I work. Nextcloud is much more than file storage. Its official site highlights files, calendars, text chat, audio and video calls, and groupware features. Right now I am using it for calendar integration, but it also has messaging and meeting tools that could become more useful over time. Joplin is my note-taking and documentation tool. Joplin describes itself as an open source note-taking app that helps capture and access notes across devices. For me, that matters because ideas are easy to lose if they are not written down well.

Posterr is another tool worth discussing. It may not be a core business app in the same way as invoicing or identity management, but it is a great example of how a Docker-based setup can support media rooms, home theaters, and polished display experiences. I like including tools like that because they remind us that good infrastructure is not only about business. It can support comfort, creativity, and better experiences too.

Finally, there is Easy!Appointments. It is not fully implemented yet, but it is on the list. Easy!Appointments is an open source booking tool that lets people schedule appointments online. It can also work with CalDAV, which is an open calendar standard that lets different calendar apps and servers sync events with each other. That could be a very useful addition for client scheduling and smoother communication.

What Comes Next

The goal is not to run a lot of software just for the sake of it. The goal is to build a stack with purpose. Every service should earn its place. It should solve a problem, save time, improve control, reduce confusion, or open the door to better service.

That is what this blog series will be about.

This first post is the big picture. It explains why Docker matters, why open source matters, and why these tools fit the way Texas 67 Systems works. The next posts will slow down and look at one main service at a time. Not the databases. Not the worker containers. Not the behind-the-scenes helper pieces. Just the main service, what it does, why it matters, how it helps, and what I am learning from using it.

If that sounds useful, stay with me. In the weeks ahead, I will break down the stack in simple language and share what is working, what still needs work, and what other small businesses can learn from this setup.

This is not just a list of containers.

It is the story of building a business system that is practical, understandable, and truly yours.

Sources

• Docker Docs, “What is Docker?”
• Open Source Initiative, “About”
• Gitea Documentation, “What is Gitea?”
• ERPNext homepage and ERPNext docs
• Paperless-ngx docs, “Usage Overview”
• Node-RED, “About”
• Nextcloud and Nextcloud Talk
• Joplin, “What is Joplin?”
• Easy!Appointments

Next in the series: Why Authentik Matters for Texas 67 Systems explains how sign-ins, single sign-on, and access control fit into the bigger picture.