Building Scalable Systems: How Pablo M. Rivera Designs Operations That Grow

By Pablo M. Rivera | Hawaii, Colorado & East Haven, CT

Any organization can operate effectively at small scale. The test of operational leadership is whether systems hold up when volume doubles, markets expand, and complexity increases. Pablo M. Rivera has designed, built, and scaled operations across industries.

What Scalability Actually Means

When Pablo M. Rivera scaled a construction company from startup to $10 million in Colorado, the systems that worked at $1 million had to function at ten times the volume. The same challenge applied at RevCon Management with 120+ technicians across 12 states.

The Three Pillars of Scalable Operations

Pablo M. Rivera builds scalable systems on three pillars: standardized processes, technology infrastructure, and distributed leadership.

Technology as the Scalability Multiplier

At RevCon, deploying Salesforce with 50+ custom objects was fundamentally a scalability investment. Pablo M. Rivera designed the CRM architecture to accommodate unlimited market expansion — reflecting the full-stack development training from Columbia Business School.

Scaling in the Hawaii Context

Hawaii presents unique scalability challenges — island-based logistics, limited labor markets, and supply chain constraints. Pablo M. Rivera applies scalable design principles to these constraints, building systems that maximize efficiency within geographic limitations.

Based in Hawaii and East Haven, CT, Pablo M. Rivera designs operations that grow intelligently, not just quickly.

Automation Without Context Is Faster Chaos

What’s Your 2026 Goal?

Hello! Have you ever wanted to "level up" in technology? Do you want to know how to solve problems at Planet-scale? Do you want to learn the "secret sauce" to develop a truly mature system that can power the crazy next big thing(tm) that you want to get on the Internet?

Well, enter the field of System Scalability, a field that I'm more than glad to talk about and share intricacies of with you.

I learned Scalability, so you don't have to :)

Scalability is the general idea that refers to whether systems, processes, tools, etc... whatever "artifact" you need to use, accomodate for bigger sizes of input. For example, it is certainly agreed upon that a scalpel is a fantastic tool to make precision cuts, but it doesn't scale to cutting down trees. This is what I mean by scalability.

Do you want to make a team of engineers go nuts? Get them in a meeting room, and ask them: "does your system scale?", which is commonly a valid question, and they will start debating nonstop that very moment, like mad.

But I digress.

If your web application or system works fine when you're serving 10 people, but it breaks when 1000 or 10,000 people try to use it at the same time, then you have poor scalability. And on the contrary, if you're a badass of engineering and you make it so your system is ultra-capable to handle massive amounts of traffic, like what people would do for massive, always-on commercial sites, then you have great scalability. Capice?.

A lot is said about scalability in tech these days, with fair reason, given how so much of what happens in society these days is so intrinsically connected to the Internet now. Developing a system which scales massively is of the essence.

Technologists: we need you. We need more people to come into the field. Are you up to it?

The following is a compendium of "rules of thumb" that you can use to architect your systems in a more scalable, robust, resilient, and fault-resistant way.

This is not an authoritative, end-all be-all list of principles for scalability: scalability is a never-ending discussion that will apply to your particular app in a different way. But at least, I'm proud to say that all of this comes from experience and war wounds, and that it's stuff that I've relied on for the past several years in my day to day.

Let's begin!

1. Know your scalabilities

There's two kinds of scalability, vertical and horizontal. Both refer to the same central concept but they go about it in different ways:

Vertical Scalability

Vertical scalability means that you achieve greater levels of scalability by "beefing up" whatever infrastructure you're running your system on.

Can you add more storage, a faster CPU, more primary memory? Does your system accomodate for scale better this way?

Bear in mind that vertical scalability is not always viable. Sure, you may be able to to add a faster CPU to your web server to alleviate your problems, or more RAM, or more Hard Disk space, but should you?. Can you afford to take your site down to change its components? You probably can't. Is throwing more money, in the sense of getting better components for your web server, really the answer? Not always.

Besides, tracking back to the previous example about CPU speed, you can only get so fast. Moore's law is a thing for a reason. Know the limits involved in vertical scalability.

So, in some cases you will be better served by horizontal scalability. Distribute things!!!

Horizontal Scalability

Horizontal scalability means that you accomodate for scale by running computing tasks across several multiple machines interconnected through the network.

Horizontal scalability is what everybody does in the industry now to get systems off the ground, and the main driving force behind the Cloud.

Horizontal scalability will usually involve the implementation of a message broker/message bus, and a load-balancing mechanism to coordinate and even out the load across multiple hosts. Many different implementations of this exist out there on the market, with many different algorithms but as long as the main principles remain, where you take your workloads and spread them out across several hosts, you will be fine.

2. Use the right algorithms, and know your complexities

Big-O analysis is a really intricate field in Computer Science concerned with determining how your system's Memory or Computing Time requirements scale depending on the size of your input. This is intrinsically related to the idea of Scalability.

Big-O analysis thus represents the CPU time and memory requirements of a system as a mathematical function of the size of the input, and if you harken back a bit to your high-school algebra, you'll remember how different mathematical functions can be graphed:

Not all computer algorithms are made equal: different approaches have different complexities. There are many ways to get to Rome, of course: you can certainly solve a computing problem many different ways, but is your solution efficient for massive inputs? Does the time or memory needed to run your function upshoot to infinite if your input shoots up to infinite? Can you be asymptotically bounded? Can you trade-off time for memory or vice-versa? These and many more are questions that you have to answer if you want your system to be scalable.

So, preferably, avoid coding your systems with algorithms which run in exponential or worse computing time. Prefer logarithmic or constant time.

3. Use the right data structures

Data structures are also very important when designing systems. Different data structures have different requirements in terms of time and memory for certain applications. Modeling your data with a certain data structure can make or break your scalability, so you really need to research and take all considerations into account when designing systems.

This point is very intimately related to the previous point.

As a rule of thumb here I recommend to aggresively use hashmaps whenever possible since it DOES help a lot. Hashmaps are a kickass data structure that flattens out runtime complexity to access a certain piece of information in a logical mapping of a set of information through the usage of a key which maps to the location of the information in memory. Most information in Existence can be modelled with hashmaps. With certain caveats, hashmaps can be arbitrarily large and allow to access a piece of information of any type in a computer system in constant time.

4. Know your concurrency

By nature, some computing problems lend themselves to being approached from a concurrent point of view, which we can call "embarassingly concurrent problems". If your problem can be solved faster through implementation of multiple threads of processing, take this avenue. But be aware that concurrency also brings its own share of problems, particularly in terms of whether you have multiple threads acting on shared mutable state, or any other side effects that a given thread may have (which as a general rule of thumb you should avoid as much as possible if you're sticking to functional programming form). Use this resource wisely: concurrency should not be applied to everything just because.

Some programming languages attempt to make concurrency easier by treating it as more of a first-class citizen, pairing it together with mechanisms that avoid shared mutable state among other niceties. Most, if not all, commercial Functional Programming languages fall here, so Scala, Clojure and Elixir, for example, are worth a look. The promise/callback model seen in all ECMA/Javascript implementations, and the Future model, which is available in pretty much every programming language these days, are also very cool, since they abstract away a lot of the nitty gritty of concurrency so you don't have to.

Follow the Reactive school of thought when architecting your systems. Bear in mind that distributed systems can have faulty network conditions, among a plethora of factors which can make intercommunication between systems or components very spotty. The Reactive pattern will be of great usage to avoid headaches down the line here, and I recommend getting familiar with the Reactive manifesto for context too: https://www.reactivemanifesto.org/

Again, it makes sense to apply concurrency to solve a given problem when you would rather not block the current thread. For example, if your system has an expensive database transaction, or a some kind of notification or email sending, you should run it concurrently and not make the current thread remain blocked during the expensive task. Which leads me to the next point:

5. Use the Pub/Sub pattern

A rule of thumb about highly scalable systems is that your system should run tasks based on message passing, placing messages into a message queue where other components of your system read from at their leisure. If you leverage the publisher/subscriber pattern for this, you've won half the battle. Tasks such as the expensive examples mentioned above, like notification sending or email sending, lend themselves well for Publisher/Subscriber.

There's a lot of ridiculously simple alternatives in the market here to implement the Pub/Sub pattern for your systems, particularly managed systems. A common one which you probably already know about is AWS SNS and SQS, both of which work in tandem beautifully out of the box to enable publisher/subscriber patterns. Leverage this as much as possible.

But SNS and SQS are not the only versions of this available out there. Some very popular alternatives are Apache Kafka, RabbitMQ and Google Cloud Pub/Sub.

6. IO is expensive so avoid it if possible

Writing or reading information to or from disk is expensive because there's way too many moving pieces involved in it. If possible, avoid reading or writing to disk. Go stateless. This includes file operations, database transactions, and anything of the sort. Every read or write involves a round trip, over the network and/or to disk, which is usually not too bad but can be cumbersome if dealing with tons of load. Minimize how many times your system has to make this round trip.

Of course you will need to store information about your users at a certain point though, so IO is in a way, unavoidable. If possible, leverage a managed service so you offload IO. Not to mention that data lifecycle management can be quite the pain! Lots of managed services solve the problem of lifecycle management so you don't have to.

7. Denormalize and cache if memory is cheap

However, do not consider IO to be the devil! Cache information that's not volatile aggresively if this saves you round trips to the database or disk!. In relational database terms, even though you're not completely being ACID, having duplicate/de-normalized information in a database helps if it means, for example, avoiding a database join or some other kind of database operation.

Cache management, again, also comes with its own share of Pains in the A, but if you're dealing with information that's not sensitive, I reccomend it.

8. Loose Coupling is awesome

Design all of your systems so their components are not tightly bound and can be swapped out easily and cleanly, if desired. By tightly bound, what I mean is whether your system's components depend directly on the implementation of each other rather than on a cleanly abstracted interface. Good programming practice and modular design is of the essence here: Always code to the Interface and prefer Composition over Inheritance. Use shared executables and libraries. If one of these components is a bottleneck (spoilers: this will happen, whether you want it or not) and you eventually find a better one, make it easy for you to make the switch.

9. Can you containerize?

Last decade, the tech world bore witness to the rise of a huge amount of virtualization technologies that made computing a truly elastic/on-demand resource to consume. Among them, a personal favorite of mine and one that is making a big splash is the use of lightweight virtualization, aka "containers"/jails.

Many operating systems available in the market have their own version of containerization implemented in their kernel; however, Debian and RHEL-like linuxes have dominated the field for the past several years.

It is possible to set up containers to spawn or die out depending on the amount of traffic that your system is receiving in a very sophisticated way. Learn the intricacies of these kinds of implementations and leverage them.

10. Can you go serverless?

Containerization capabilities like the ones I mentioned before have allowed new services and abstractions to come up in the market to make your life easier as a developer. One of them of particular importance is the rise of "functions-as-a-service", which provide a way to run application code without having to maintain an application server running.

The nice thing about the functions-as-a-service paradigm is that it removes tons of moving pieces from the whole equation and by nature scales with your traffic, but this is pretty bleeding edge territory and it doesn't necessarily fit everybody's use cases. Be careful if you decide to go this way.

11. Split functionalities between microservices

Service-driven architecture has a wide variety of tenets, among which I should highlight the Microservice orientation.

In my opinon, unless you're a humongous enterprise that needs to deploy systems for world-scale, you usually don't need microservices and you will be better served by a well-written, clean monolith. But we want to learn about world-scale, right? That's why you came here in the first place ;)

Think about the workloads that you're running in your system. If you expose an API, are some of your endpoints receiving substantially more traffic than others?

You may want to abstract the code that serves such endpoints onto a new microservice of its own, and apply all of the scalability principles discussed above to it. A very common use case is authentication and authorization. Do you need to implement a system of its own for authentication because you could use horizontal scaling to make it work better with traffic spikes? Maybe your system needs a search engine for some reason, can you implement the search engine as a separated system and scale it up?

There's a lot of nuance and a lot of give and take in this regard, so exercise caution. Again, not everybody should do microservices, but a lot of times, it truly is the answer to a lot of issues when you're trying to scale your system up.

12. Regionalize, failover and implement redundancy.

The Cloud has made a made a massive amount of computing resources available to engineers worldwide at the push of a button. Getting a cheap and fast web server wherever in the world is as simple as an API call, with a lot of guarantees behind it about geographic location and avialability.

So, be liberal with your compute. Deploy your application with redundancy. Have as much capacity running your application as possible and load-balance and failover as needed. This adds resillience to your systems, and makes them more reliable. Remember that this is a part of scalability, what happens if you lose your system in a certain location? Have you prepared for that?

I reccomend an approach, as in, run your application in at least three different geographical regions, in at least two availability zones per region. Availability zones are concepts specific to the Cloud, which are datacenters that are logically isolated so if one goes down, all others in the region never go down.

And in the very rare case that all availability zones go down at the same time, which is already statistically unlikely to begin with, then running your application in another region will come in handy. There's failover mechanisms to set up your clients such that they can use an auxiliary region in case that the server they're trying to consume from goes down.

If your application is globally consumed, deploy to all possible regions as you can in the Cloud such that your customers can reach the closest datacenter possible. Don't run all of your system in a couple sole regions.

Also run your system on-premise alongside the cloud for added redundancy if this is a possibility. Sometimes... going back to basics is good :)

13. What you don't measure you can't improve: Observability is King

You should be smart about what's happening with your system. What if a part of your system is terribly slow but you're not tracing it? How can you know exactly what to improve for better scale, if you don't even have any data to begin with?.

Define KPIs as needed for your system and implement monitoring solutions to track them over time. One that is very popular and that fits very well with the AWS ecosystem is AWS Cloudwatch, which has a lot of pre-baked metrics for its native systems that you can use to inspect how your system runs.

You probably also want to trace the lifetime of a request of one of your customers to know what happens to them as you go along. Implement tracing with tools such as Envoy, which is very popular in the tech world at large, and learn to use them to your advantage for this.

14. And finally... can you not develop a system to begin with? :)

And... I'd like to conclude this article with a little bit of wisdom.

When you start in the field you're usually very excited about developing your own systems. You love programming, you love coding and testing and all of that good stuff, and you love to see your customers enjoy using your system. Life is good.

Imagine that you have a new stakeholder with a certain need and you have to satisfy it. For the sake of an example, let's say that your customer is a merchant, who wants to sell their wares to a wide variety of customers. They handle production and distribution, you just need to handle the information worldwide.

Then you start developing a web application. You already have ideas in your mind about what to develop the very moment you learned about your client. You love jumping in with other developers and discussing programming paradigms and design patterns. You bring out the newest thingamajig in the industry and you use the newest, flashiest, most cutting edge programming languages. You keep going down the rabbit hole, more and more and more. You rack up your cloud bill, and then some, and then some, and then some...

You love to produce a lot of code, fast, because you're a good developer and you're smart and you love your craft. You love to, figuratively, watch your system stand and you hit it with a loud thud and, since it's enterprisey and highly scalable and all, it makes big, bad ass loud clanks every time you do so. You are proud of yourself. You puff up your chest and you pat your colleagues in the back. Life is good.

Eventually, your system has so many little crevices and so much complexity that it becomes a burden to deal with. You need staff to maintain it. You need staff to keep it running. Things constantly break down and it becomes a whole bunch of upkeep. The customer wants changes because... well, the customer will always need changes, and making changes is a pain. Or maybe you didn't understand the specifications to begin with and your customer is making do. Or maybe you made things "your way" and it's not the way that the customer wanted things done. It's a problem of misconception now.

Then some members of your team start re-designing and re-architecting and re-factoring your system, and now you're stuck in this hellish thing that you didn't mean to get stuck in.

Remember: you were only trying to satisfy a stakeholder's needs. You were only solving a problem.

...

And what about this: what if, all along, your customer sold, let's say, tacos? What if you just set up a shopify account for them instead of baking your own system, for example? What if they didn't need software to begin with, they may just need a Google Docs file and a Simple Static Website?

What if that gave them what they needed rather than what you wanted to do, to begin with?

...

Very broad example, I know, but I think it still conveys the point: avoid falling into the trap of doing tech for the sake of doing tech. Be clever. Be critical. Solve problems rather than coding software to fill the hours in your day. Understand people, understand the customers that you work for, and understand what really is needed in your industry. You'll be amazed at how simply some problems can be solved.