The Problem

For much of my career, I’ve built mobile apps and led mobile organizations. Mobile apps have a rule: build numbers only go up. Google Play rejects an app bundle whose versionCode isn’t higher than the previous one. TestFlight is just as strict.

GitHub gives you GITHUB_RUN_NUMBER out of the box which can be used for build numbers, and for plenty of teams that’s fine. But it’s scoped to a single workflow. Split your CI into separate workflows for PRs and releases, and now you have two counters that disagree with each other. And you can’t seed it. If you’re migrating from something like Jenkins and your last build was 4,873, GitHub cheerfully starts you back at 1.

I wanted one counter for the whole repo that I could start anywhere.

Usage

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - name: Generate build number
      uses: onyxmueller/build-tag-number@v1
      with:
        token: ${{ secrets.github_token }}
    - name: Print new build number
      run: echo "Build number is $BUILD_NUMBER"

Every later step gets a BUILD_NUMBER environment variable. There’s also a step output, steps.buildnumber.outputs.build_number, if you wanna pass it to other jobs. I feed it to Gradle as the versionCode.

The trick: your repo is already a database

The counter is a git tag. When the action runs it finds the ref build-number-42, creates build-number-43 on the current commit, and deletes the old one.

Here’s why I like this design:

• No external service. Your repo already stores refs. It can store one more!
• No extra commits. The tag rides along without touching your history.
• It’s seedable. Moving from another CI system? Push git tag build-number-4873 and the next build is 4874.
• It’s fast. The whole action is one JavaScript file with zero npm dependencies. It calls the GitHub API with Node’s built-in https module. A build-number generator shouldn’t spend thirty seconds installing packages to add one to a number.

Multiple Counters

Got a client and a server in one repo? The prefix input gives each its own counter:

    - uses: onyxmueller/build-tag-number@v1
      with:
        token: ${{ secrets.github_token }}
        prefix: client

That creates tags like client-build-number-12, independent from server-build-number-31. And if you want to keep every old tag as a paper trail, set delete_previous_tag: false.

Why I Do This

Build Tag Number is not impressive engineering. It adds one to a number! But it runs in pipelines I’ll never see, for developers I’ll never meet, and every so often one of them shows up in my issue tracker to tell me how they’re using it. Some send pull requests that make it better for everyone.

I’ve spent twenty-plus years building software for big brands. Watching a tiny tool I shared quietly help strangers still beats most of it. That feeling is why I do open source.

You probably have a small utility that scratches your own itch. I encourage you to share it.

And if your builds need numbers that only go up, check this out.

Then the mysteries started happening.

Devices would drop and reconnect for no reason I could find. The mesh point in the garage lost its backhaul about once a week and needed a power cycle to come back to life. A video call would stutter, I’d open the app to look, and by the time it loaded the problem had cleared on its own. Nothing I could reproduce, nothing the diagnostics would admit to, and no real way to see what was actually happening. A consumer router tells you the Wi-Fi is “good.” It will not tell you why your laptop just decided to talk to the point two rooms away.

So I did the calm, proportionate thing and rebuilt the entire network on UniFi.

If you haven’t fallen down this particular hole, UniFi is Ubiquiti’s line of prosumer networking gear: gateways, switches, access points, cameras, the works, all managed from a single console. You buy the hardware once and the software is free for as long as you own the device. No subscription, no feature held hostage behind a monthly tier. VLANs, guest networks, firewall rules, intrusion detection, Wi-Fi schedules: all standard, all free. The Nest Wifi wasn’t hiding these settings from me. It just didn’t have them. You got a guest network and a button to pause the kids’ devices at dinner, and that was about the extent of the control on offer.

The part that actually sold me is that you grow into it. Start with a gateway, add a switch when you run out of ports, add an access point when you run out of coverage, and the controller ties the whole thing together as you go. You don’t tear everything out to gain one feature. Fair warning, though: buying this stuff is addictive. The catalog is deep, the hardware is genuinely nice to hold, and there is always one more box that would make the setup a little better. Ask me how I know. Just don’t tell my wife.

The single best part (and the thing I find myself opening for no reason at all) is the dashboard. Every client, every access point, every flow, in one place. After years of a phone app that showed me a list of connected devices and a restart button, seeing the whole network laid out felt like flipping the lights on in a room I’d been walking through in the dark. Every smart-home gadget in the house is right there in the client list, and I can finally see exactly what each one is chatting to.

The gateway: Dream Router 7

The heart of all this is the Dream Router 7. It’s a router, a firewall, the UniFi controller, and a Wi-Fi 7 access point in one box that sits on a shelf in my basement and quietly runs everything. For a house this size that all-in-one shape is exactly right. No rack, no separate controller appliance, no second machine to babysit. CenturyLink fiber comes into the house and the DR7 takes it from there.

Its Wi-Fi 7 radios aren’t sitting idle either. They’re part of the mesh, covering the basement themselves while the dedicated access points handle the rest of the house. If you want PoE built into the gateway, the Dream Machine SE is the step up, but for a small home that’s more box than I’ll ever fill.

Switches

Three PoE switches handle everything wired, all in the basement. A USW Lite 16 PoE is the workhorse, fanning out to the wired access points with a stack of ports to spare, which is the whole point. When I add a camera or another AP, I won’t have to think about where it plugs in.

Two USW Lite 8 PoE switches pick up the rest. One tucks in right under the Dream Router and anchors the backbone; the other feeds a cluster of always-on gear, the kind of boxes that are happier on a cable than on Wi-Fi.

The reason they’re all PoE and not whatever was cheapest: power over ethernet means one cable does both jobs. An access point gets its data and its power from a single run, no wall wart, no hunting for an outlet behind the furniture. My wiring closet went from a tangle of little black power bricks to a few tidy ethernet runs. And the house’s original Cat 5e carries gigabit without complaint, so I didn’t rewire a thing, no matter what the internet insists you have to do.

Access points

The Dream Router covers the basement on its own, and four access points handle the rest of the house, all Wi-Fi 7, all placed where the network actually gets used rather than wherever happened to be convenient.

The workhorse is a U7 Pro Wall on the main floor, where the family spends most of the day. Despite the name, mine is not on a wall. A table stand accessory holds it upright on a shelf next to the TV, no drilling required, which kept the peace at home.

A U7 Lite lives on a bookshelf in the master bedroom. It’s Wi-Fi 7 at a fraction of the Pro’s price, and it’s plenty for a room that mostly streams to a TV and keeps a few phones alive overnight.

A U7 Mesh takes the guest bedroom and that side of the house. It’s a compact little thing, easy to place, and it means guests get a strong signal without me leaning on the bedroom AP to reach somewhere it was never meant to.

Outside, a U7 Outdoor is mounted to the side of the house, facing the patio. It covers the back patio, holds onto the Sonos out there, and throws a strong signal into the garage so the EVs stay connected while they charge.

If there’s one trap to avoid, it’s the urge to keep adding access points and crank every radio to maximum, because the slider is right there and bigger numbers feel like they should be better. Resist it. A few APs at sensible power beat a pile of screaming ones, because the screaming ones make your phone ping-pong between them in the middle of a sentence. I spent more time choosing where things went than touching any actual settings, and that’s the part that paid off.

A month in

The short version: the flaky stuff is gone. My phone holds onto one access point as I walk the house instead of white-knuckling the first radio it grabbed at the front door. Calls don’t drop. I haven’t power-cycled anything, which after the old setup feels like a small miracle.

Setup was easier than the gear list makes it sound. You plug a device in, the controller spots it, you click adopt, give it a name, drag it onto the map, and you’re done. The defaults are sane. When I do want to change something, it’s usually where I’d expect to find it, and the settings I don’t recognize are at least labeled in plain English instead of a wall of acronyms.

I’ve already gone further than I expected to. There’s a dedicated IoT network now, walling off the smart-home devices from everything that matters, and real firewall rules to go with it, including region blocking so the network stops talking to corners of the internet it has no business in. There’s still a long list I haven’t gotten to: Teleport VPN for reaching home from the road, the Protect cameras everyone keeps telling me to buy, the travel router that follows you into hotel Wi-Fi. I’ll get to all of it. Probably sooner than my budget would prefer.

The full list

• Dream Router 7 (gateway, firewall, controller, and Wi-Fi 7, all in one)
• USW Lite 16 PoE (main switch, feeds the wired APs)
• USW Lite 8 PoE x2 (one anchors the backbone, one for secondary wired gear)
• U7 Pro Wall on a table stand (main floor)
• U7 Lite (master bedroom, upper floor)
• U7 Mesh (guest bedroom, main floor)
• U7 Outdoor (patio and garage)

I’m a big Dave Chappelle fan. And an even bigger fan of Chappelle’s Show. For years I’ve wanted to build a digital version of the “Wrap It Up” box from one of the show’s skits. The gag riffs on a familiar award-show moment: a celebrity’s speech runs long, the orchestra starts playing, and they’re hustled off stage. The Chappelle version added a twist: a portable box you could pull out anywhere to shut someone down mid-sentence.

It lived in the “someday” pile for years. Fun concept, too many fiddly details to bother with on a weekend.

Then I just… built it. I described what I wanted to Claude (faithful 3D recreation, interactive button, flashing text, audio) and we worked through the implementation together. 2D or 3D? How to handle audio? How to make it work on mobile? Questions that used to eat hours of searching became quick decisions.

The result: WrapItUpBox.com, a fully functional, responsive web app.

The speed is what surprises me. The whole thing happened in hours. AI didn’t just write code; it helped me think through how to build the thing: trade-offs, constraints, approaches I wouldn’t have known to consider.

The ridiculous ideas I’d always shelved because they weren’t worth a week of my time? They’re worth an afternoon now.

And if that’s not worth doing… well, you know the line.

One of my favorite segments was called “What is everybody consuming?” It was a simple idea: open the floor and invite folks to share what they were watching, reading, listening to, or otherwise enjoying in the moment. Movies, TV shows, music, books, podcasts, art - everything was fair game. And every time, it sparked fantastic dialogue. I learned so much about my team through that segment… what moved them, what made them laugh, what kept them up at night. It was a small thing that brought us closer.

Somewhere along the way, I thought: Maybe there’s others outside of work that are wondering what I’ve been consuming lately, too.

That’s what led me to build a Now page.

The concept of a Now page was originally introduced by Derek Sivers, and it’s a beautifully simple idea: a single page on your personal site that answers the question “What are you focused on right now?” It’s more dynamic than an About page, and more evergreen than a social feed. It’s a digital snapshot of what’s currently capturing your attention.

But there was one problem: I’m lazy.

I knew if I had to manually update my Now page every week or month, I’d probably forget, then feel guilty, then avoid it altogether. So I asked myself… what if I could automate most of it, if not all of it?

That kicked off a fun little side project to make my Now page data-driven. The goal was to have it quietly update itself periodically in background, pulling in information from the places I already engage with media - no extra work required.

Here’s how I made it happen:

• Books: I use Hardcover, a fantastic service for tracking your reading life. Using their API, I can fetch what I’m currently reading, along with the progress I’ve made. The API is clean and well-documented, and I love supporting an indie, book-loving alternative to Goodreads.

• Music: Spotify’s API gave me access to my most frequently played tracks and artists over the past few weeks. I pull the results from the Top Tracks endpoint, and surface them as a snapshot of what’s been on repeat lately.

• TV & Movies: I host most of my media on a self-hosted Plex server, and luckily, Plex provides a local API to access viewing history. With a little digging (and some reverse engineering), I was able to pull recently watched content and surface it automatically. If I watched it, it shows up - simple as that.

The result is a living, breathing Now page that reflects what I’m actually consuming across books, music, and movies/shows in near real time. No guilt. No manual updates. Just vibes.

I really like how it turned out. And more importantly, I love the spirit behind it… sharing a little slice of life in a way that’s honest, human, and maybe even inspiring to someone else.

So if we’re friends (or even if we’re not), and you ever find yourself wondering what I’ve been into lately, check out my Now page. Better yet, make your own. I promise, it’s worth it.

More Than Just a Paycheck

I’ve been lucky enough to be part of delivering 10 March Madness tournaments to millions of fans - many of them wildly successful (as evidenced by winning one Sports Emmy and several nominations). I attribute much of that success to being in a thriving culture that allowed teams to work really well together and people to do amazing work. It wasn’t just about executing a massive event; it was about being part of an environment that fostered collaboration, trust, and innovation. That culture was the foundation that enabled us to meet challenges, push boundaries, and create unforgettable experiences.

We all want to be part of something inspiring. Work is more than just a series of tasks or a paycheck. It’s a significant part of our lives. The best workplaces understand this and cultivate an environment where people feel connected to a purpose bigger than themselves. When employees believe in the mission and feel valued, their engagement, creativity, and commitment soar. They’re not just showing up to do a job; they’re invested in making a difference.

Culture is the OS

Think of culture as a company’s operating system. It’s both the visible and invisible wiring that connects people, guiding them with a shared sense of purpose, clarity, motivation, and focus. It influences how decisions are made, how teams collaborate, and how challenges are tackled. A strong culture doesn’t happen by accident. It is intentionally built and maintained, ensuring that everyone is aligned and empowered to do their best work.

A Force Multiplier

A great culture doesn’t just support a company’s success; it amplifies it. It’s a force multiplier, elevating individual capabilities and enhancing team performance. In an environment where trust, collaboration, and innovation thrive, people push boundaries, take smart risks, and create extraordinary work. Culture sets the conditions for success. Not just for today, but for sustained excellence over time.

Building a Superpower

So how do you cultivate a culture that becomes a superpower? It starts with leadership that prioritizes clarity, inclusion, and a shared vision. It requires trust and psychological safety, where people feel empowered to contribute their best ideas. It thrives on transparency, communication, and a deep commitment to continuous improvement.

Companies that embrace culture as their superpower don’t just attract top talent. They retain and elevate them. They create workplaces that people are proud to be a part of, where purpose drives performance, and where the impact of their work extends far beyond the walls of the office.

Culture isn’t a perk or an afterthought. It’s the foundation of greatness. When done right, it’s the difference between a company that merely operates and one that truly thrives.

Early in the book, Rubin delves into an idea that I’ve reflected on for years: that everyone is inherently creative.

Creativity is not a rare ability. It is not difficult to access. Creativity is a fundamental aspect of being human. It’s our birthright. And it’s for all of us. Creativity doesn’t exclusively relate to making art. We all engage in this act on a daily basis. To create is to bring something into existence that wasn’t there before.

This concept shifts how we think about creativity. It’s not something reserved for artists, musicians, influencers, YouTubers, or for magical moments of inspiration… but as a natural part of life. It’s everywhere, even in the small, everyday things we do. For example:

• Parenting: Parenting is a constant exercise in improvisation. I’m always amazed by how my wife navigates challenges with our kids, whether it’s problem-solving, inventing fun activities, or managing tantrums. It’s all creativity in action.

• Cooking: While recipes can guide us, there’s often room for adaptation and experimentation. Finding joy in this process is a creative endeavor.

• Conversations: Whether it’s telling a story, offering advice, or making someone laugh, creativity plays a role in how we connect with others.

• Navigating Your Day: The way you organize your time, space, or even the choices you make on your commute can be an act of creativity.

• Humor: Life throws us curveballs. Finding something funny in life’s challenges is such a creative response. It takes perspective and imagination.

Rubin’s message is a great reminder that creativity isn’t just about making art. It’s about how we approach life… how we approach challenges, improve routines, connect with others, and make everyday decisions. By recognizing creativity in the ordinary, we can uncover beauty and possibility in unexpected places.

We are all creators.

I’ve dealt with fan noise before on Windows using Fan Control, which lets you adjust fan speeds based on CPU and motherboard temperature sensors. But unfortunately that was not usable since server OS is Linux-based. Moreover, Intel NUCs don’t have software-controllable fans.

BIOS to the Rescue

After some research, I found that the NUC’s BIOS actually has a pretty robust set of cooling controls.

With a bit of tweaking, I was able to dramatically reduce the noise without sacrificing stability. Here’s what worked for me:

• Set the Fan Control Mode to “Custom” – This allowed me to fine-tune the cooling settings instead of relying on Intel’s defaults.

• Lowered the Minimum Duty Cycle to 20% – By reducing the idle fan speed, the NUC became significantly quieter when not under load.

• Disabled Turbo Boost – Since this machine doesn’t need high performance, turning off Turbo Boost kept the CPU cooler and prevented unnecessary fan ramp-ups.

• Switched the Power Management State to “Low Power” – I’m not 100% sure what this setting tweaks under the hood, but given this machine’s role, prioritizing efficiency made sense.

The Results

After applying these changes and rebooting, the NUC was MUCH quieter. If you’ve got a noisy Intel NUC driving you crazy, diving into the BIOS settings might be all it takes to quiet it down.

Why Build This Library?

After developing the Pinata Ruby Library to enhance backend workflows, I realized the mobile community could benefit from a similar tool. Whether you’re managing file uploads, retrieving metadata, or integrating with Pinata’s infrastructure, this library provides the tools you need.

Android developers can now avoid the hassle of tedious API calls. The Pinata Android Library offers clean abstractions and a modern API design, specifically tailored for Kotlin and Java projects.

Key Features

• Simplified Integration: Get started with just a few lines of code.

• API Coverage: Focused on the Files API for seamless file uploads, retrievals, and metadata management.

• Kotlin-first Design: Built with Kotlin, ensuring modern language features and interoperability with Java.

• Open Source: Fully open-source, for transparency and collaboration.

Getting Started

Adding the library to your Android project is straightforward. Head over to the GitHub repository for installation instructions, detailed documentation, and code samples.

Here’s a quick example to showcase how easy it is to upload a file:

val pinataClient = PinataClient.get(YOUR_PINATA_JWT_TOKEN, YOUR_PINATA_GATEWAY)
val result = pinataClient.files.upload(file)
result.onSuccess { response ->
    println("File CID: ${response.cid}")
}

Try It Out

This library aims to make Pinata’s API more accessible to mobile, providing Kotlin-friendly extensions and abstractions for Android developers. Currently, the library supports the Files API, but will continue to evolve to support more of Pinata’s functionality over time.

For full documentation, visit the GitHub repository: Pinata Android on GitHub. To learn more about the Files API, refer to the official Pinata API docs.

I hope you find this library useful for your projects! Contributions are always welcome!

What Makes Pinata’s Files API Special?

Pinata’s Files API is a centralized storage solution designed to complement its decentralized IPFS offerings. It provides developers with:

• Simple File Storage: Upload, organize, and access files with a clean and powerful API.

• Cost Efficiency: Affordable plans that scale with your needs.

• Fast Integration: No need to wrestle with complex configurations. The Files API is designed for immediate usability.

• Data Redundancy and Security: Your files are stored securely with built-in redundancy for reliability.

The Files API is ideal for developers who need traditional storage capabilities but with the developer-friendly ethos Pinata is known for.

A Ruby Solution for Pinata’s Files API

Pinata’s Files API is an incredible tool, but until now, Ruby developers lacked a dedicated library for leveraging its features. To address this gap, I’ve developed an open-source Ruby gem: Pinata Ruby.

This gem provides an elegant and intuitive way to interact with the Files API, enabling Ruby developers to upload, retrieve, and update their files effortlessly.

Getting Started with the Pinata Ruby Library

Installation

To install the gem, add it to your Gemfile:

gem 'pinata', '~> 1.0'

Then run bundle to complete the installation.

Configuration

Create your Pinata client with your Pinata API key:

require 'pinata'

client = Pinata::Client.new(jwt_key: 'your_api_jwt_key')

Authentication

Test your ability to connect to the Pinata API with the key:

client.authentication.test

Uploading a File

Uploading a file is as simple as:

result = client.files.upload_file(file: '/path/to/your/file')
puts "File stored with CID: #{result.cid}"

Listing Files

Access your stored files easily:

files = client.files.list
puts "Total # of files: #{files.data.size}"  

Updating File Name or Metadata

The gem also includes methods to update or delete files and folders:

result = client.files.update(file_id: "the_file_id", "name": "new_name_of_file")
puts "New name of file: #{result.name}"  

Try It Out

This library aims to make Pinata’s Files API more accessible to Ruby developers, saving time and effort while promoting scalable file storage solutions. It will grow to support more functionality provided by the API over time.

For full documentation, visit the GitHub repository: Pinata Ruby on GitHub. To understand more about the Files API, check out the official Pinata API docs.

Take your file storage to the next level with Pinata Ruby. Try it out, and build something amazing!

Gandi’s LiveDNS API And Personal Access Token

Gandi provides a range of APIs for customer use, including the powerful LiveDNS API that enables users to update their DNS records dynamically. To access these APIs, all you need to do is generate a Personal Access Token. You can generate one from your account security page:

• After logging in, click the down arrow next to your username in the top right corner.

• Select “User Settings”.

• Scroll down to “Personal Access Token (PAT)” and select “Create a token”.

• Choose your organization.

• Enter a token name, give it an expiration date, and scroll down to “Domains” to check “Manage domain name technical configurations”. Click “Create”.

You should see a screen similar to the following.

Once you’ve secured your new Personal Access Token, you can use it in your scripts, like the one below.

Implementation Using Ruby

Here’s a Ruby script that serves a specific purpose - it uses Gandi’s LiveDNS API to determine the current IP address and update DNS. This script is a straightforward implementation of the API.

#!/usr/bin/env ruby

gandi_token = "REPLACE_ME_WITH_YOUR_GANDI_TOKEN"
gandi_domain = "REPLACE_ME_WITH_YOUR_GANDI_DOMAIN"
gandi_subdomain = "REPLACE_ME_WITH_YOUR_GANDI_SUBDOMAIN"

# Get external IP address
external_ip = `curl -s ifconfig.me`

# Update the A record of the subdomain using a PUT request to Gandi's LiveDNS API
livedns_endpoint = "https://api.gandi.net/v5/livedns/domains/#{gandi_domain}/records/#{gandi_subdomain}/A"
cmd = "curl --silent --fail -X PUT -H 'Content-Type: application/json' -H 'Authorization: Bearer #{gandi_token}' -d '{\"rrset_ttl\": 1200, \"rrset_values\": [\"#{external_ip}\"]}' #{livedns_endpoint}"
output = `#{cmd}`

# Check exit code
if $?.exitstatus != 0
  puts "ERROR: Gandi DNS update failed. Exit code #{$?.exitstatus}."
  exit 1
end

What is happening here? To start, the script relies on some variable assignments, including the aforementioned Gandi Person Access Token. Then it retrieves the public IP address from ifconfig.me, a free service operated by IPinfo. With that, it then attempts to update the ‘A’ DNS record for the subdomain using the LiveDNS API. If the execution goes well, no errors should be reported.

Running The Script

Finally, the script should run periodically since we want to counter unpredictable IP changes. A 30-minute interval makes for a reasonable balance between API consumption and non-commercial service availability. We can declare such a job using the guidance I provided in my Scheduling Commands With Cron On Your Mac post.