Nothing ruins a hunt like becoming the hunted. Thermacell wants to protect you from the buzz (and bites) of mosquitoes so you can focus on the details of your hunt.
A Portable Mosquito Repeller by Thermacell can alleviate the pains of early-season hunts by creating a zone of protection around you.
Part of hunting is staying still in a stand so wildlife doesn’t detect you. That’s hard to do while mosquitoes are swarming you. Even if they’re not biting, they’re buzzing around you, which can range from distracting to making you wait until the first freeze to hunt.
If whitetail hunting takes you into the woods where summer-like conditions persist, like fighting off mosquitoes, perhaps it’s time for a new approach.
There are a few ways that Thermacell stands out from other mosquito and insect repellents.
First, there’s the way it works. Unlike general bug-repellent lotions and sprays, Thermacell repellent isn’t applied to your skin and thus doesn’t need reapplication midday.
Instead, the portable devices use a small, unscented mat that holds the repellent and, once heated, disperses a vapor around the device. Thermacell says the repellent creates a zone of mosquito protection up to 15 feet away. The activated mats can last up to 4 hours.
The active ingredient in the repellent mats is allethrin, a synthetic version of pyrethrin that’s found in plants like chrysanthemums — and data supporting this claim has been reviewed and accepted by the U.S. EPA.
The recent builds of these models have improved on the original designs with a quieter ignition. That’s something hunters will care about once they’re in the stand.
Hunting Companions
Thermacell makes two portable mosquito repellers for hunters to consider:
Thermacell MR300: Hunters take note — this portable repeller can be ordered in a deer camo print. The redesigned holster clips onto your belt and holds extra mats and fuel cartridge refills. (It can be ordered separately with the MR450.)
Thermacell MR450: This model adds a rubber over-mold to withstand some abuse, as well as a clip for wearing or mounting below you. It also has a zone-check indicator so you know when it is active.
(Photo/Thermacell)
No Smell
We get it — you’ve got all kinds of unscented gear and cover sprays. But, if you’ve found yourself ending a hunt early because you became the hunted, perhaps it’s time to stop worrying about whether a slight odor may spook deer and try hunting in peace.
One of our reviewers wrote that Thermacell repellent is a must-carry for early-season turkey hunts. He placed it upwind and below him for the most coverage. And while he detected a slight odor, he decided it worked for early-season deer: “I put more emphasis on the wind direction and stand location, and I worry less about smelling like nothing.”
Thermacell says its fuel cartridges are scent-free, and the brand also sells Earth Scent refills.
If you’ve been using other mosquito repellents to prevent a hunt from becoming an all-day blood donation session, consider the Thermacell portable repellents as a mess-free alternative.
Freedom From Mosquitoes: How Thermacell’s Portable MR300 Battles the Bugs
The Thermacell MR300 Portable Mosquito Repeller repels mosquitoes by creating a 15-foot zone of protection for your hunt, campsite, backyard, or adventure outings. Read more…
I ranted about hiring interviews, and the canned questions that people have to answer.
One of the interviews we do is a systems design interview, where we want to see how (senior) people use components and patterns to design a system for reliability and scaleout.
It is 2010, and the company has a database structure where a fixed number front end machines form a cell.
Reads and writes are already split:
Writes go to the primary of a replication tree, and are being replicated to the read instance of the database in each cell.
Reads go to the database instance that is a fixed part of the cell.
Read and write handles are split in the application. Clients write to a primary MySQL database, which then replicates to a database instance that is fixed part of a cell. Clients from a cell read from this fixed replica.
Unfortunately, this is not very effective:
The data center has 10 cells, but when a cell overloads its database spare capacity from other cells cannot be utilized.
Also, the data center is not redundant.
We want to:
Load balance database queries.
Extend the architecture to more than a single data center (or AZ).
Optionally be resilient against the loss of individual databases or a full AZ.
Possible topics or annotations from a candidate:
What kind of strategies are available for load balancing database connections?
DNS, Anycast or L2 techniques
Proxy (but not a web proxy)
Zookeeper or another consensus system with modified clients
What are the advantages or disadvantages of this?
L2. Huh. Don’t do that.
DNS updates are slow and complicated. It can be made to work, but you will always have very little control over what is balanced why and how. DNS is better used for a global load balancing of http requests, and not as a database load balancer.
Zookeeper could be used to do this with modified clients, but we would have to discuss how exactly that works. That’s an interesting subquestion of its own.
MySQL Router or ProxySQL are made for that, but have a lot of interesting subquestions of their own. See below.
What else may be different when load balancing database connections instead of http?
Webproxies are not good database proxies. The database protocol is not http, and it is a stateful protocol. This requires extra care when load balancing.
Database connections can be long lived. A load balancing action to a different client only ever happens on connect. If you disconnect and reconnect only every 100 web actions or so, it is possible for the system to rebalance slowly. On the other hand, if you are using TLS’ed connections, connection setup cost can be high, so longer lived connections amortize better.
Database connections have a highly variable result set size size. A single select may return a single value of a single row, or an entire 35 TB table. If the proxy tries to be too intelligent and does things with the result as it passes through, it can die from out of memory.
Proxies can become bottlenecks. Imagine 50 frontends talking to 10 databases via a single proxy on a typical 2010-box with a single (or two) 1 GBit/s network interface, and results contain BLOBs.
What else there is to know?
Replication scales only reads. As this is a shared nothing architecture, each instance eventually sees all writes. To scale writes, we have to split or shard the database. That is out of scope for this question.
In our specific scenario, the number of writes is not actually a problem. We can assume a few hundred writes per second.
Can we extend that to more than one AZ?
Yes, we can create an intermediate primary in each AZ, which takes the writes from the origin AZ into each sub-AZ. It then fans out to the local replicas. This saves on long distance data transfer. It also creates mildly interesting problems for measuring replication delay.
Because the replication tree is deeper, writes take longer to reach the leaves. Most applications should be able to accomodate that.
The alternative would be something with full Two-Phase-Commit, but that would be even slower, and would have scaling limits in the number of systems that participate in the 2PC.
This is usually how far we get in a single interview session, and only with touching only on some of these points.
To find all is completely unrealistic, even for experienced people.
We would now reach a point where we discuss failure scenarios.
But it would be highly unusual to get this far, and that is not actually the goal in an interview.
I do in fact hardly care about the solution we end up with.
My goal is to have a useful discussion about databases, scaleout and resiliency, and about stateful systems and their limits.
When there are remarks such as “Our environment is smaller, but for us … works” or “We tried this: … but observed that often …” that’s actual gold in an interview.
Even things such as “In HTTP one would do … but I can imagine that with stateful systems that does not work because …” is already old, because it shows a level of reflection and insight that is rare.
The objective is not to reinvent our 2021 setup. The objective is to use this clearly limited setup as a base for a common conversation about database probems.
“Database Reliability Engineer” is the hardest position to hire for in my environment, because it is an H-shaped qualification
The concept of H-shaped people is a metaphor used in job recruitment to describe the abilities of individuals in (or outside) the workforce. The vertical bars on the letter H represent the depth of related skills and expertise in a single field or discipline, whereas the horizontal bar is the ability to combine those two disciplines to create value in a way that was hitherto unknown.
The objective is to find a person that “Understands MySQL” and “Understands Python or Go” (“Understands any database” and “Understands a useful programming language”), so that I can throw them at our existing codebase and have them useful within 3-6 months – ugh.
If I can find one person per year, I am very lucky.
Nearly every task you can perform on a tree, whether it’s cutting it down, de-limbing it or stripping the bark, can be done by a machine. Indeed they often require one.
However, one tree-borne task for a specific type of tree resists automation and can still only be performed by humans using hand tools . That task is stripping the bark from a cork oak tree, for the purpose of turning it into cork. The bark has to be removed cleanly, so as to avoid damaging the tree; the bark will regenerate, but it will be another nine years before one can harvest it again. If you’re too heavy with the axe, you risk leaving a gash in the tree beneath the bark, which then becomes an entrance for insects who will destroy the valuable cash crop.
Here’s a look at the process in Portugal, the world’s largest producer of cork. And while it might seem like fun to cleanly peel a tree, the work and conditions look absolutely grueling:
When I watch stuff like this, I can’t believe I ever just tossed a cork in the garbage.
Ok, can we talk about how this actually worked? I really saw that ending differently, but apparently hitting a gator on the head with a trash can lid is an acceptable wrangling strategy. Did not see that coming.
More than 30 years ago, Larry David and Jerry Seinfeld brought an impressive innovation to the TV sitcom: Protagonists who are uniformly terrible people.
Sure, Married… with Children’s deplorable Bundys had been on air for a couple of years, but that series was on Fox—then a small upstart network—and an explicit parody of family sitcom tropes, while Seinfeld was, at least on the surface, a more traditionally structured show. It was also in the big leagues, airing on NBC, and the terribleness of its central characters was a lot more subtle: Jerry, George, Elaine, and Kramer made us love them while also reflecting some of our worst flaws, overreacting to small slights and petty annoyances in all the horrible ways we’d probably like to, if we thought we could get away with it.
After a rocky start in the ratings, it broke out in a big salad way, and was a ratings monsters through the remainder of its nine-season run. It has remained a favorite in reruns (and, more recently, on streaming services) ever since—thanks in no small part to an all-time great cast. Its even darker spiritual sequel, Curb Your Enthusiasm (which featured a whole season revolving around a fictional Seinfeld reunion special) is still going strong. Oh, and Seinfeld’s coming to Netflix starting Oct. 1—the streaming giant having paid some $500 million to grab the rights away from rival Hulu—so you’ll be able to while away your fall visiting or revisiting the gang.
Maybe you’ve never watched the show, and are feeling left out of this particular pop culture moment, or maybe it has just been a couple decades and you need a refresher. If you don’t want to immediately dig into 180 episodes, you can take a representative sample and totally get the gist (not hard when the show is about nothing, am I right?). Like a lot of TV, this show peaked somewhere in the middle seasons, and despite some minor plot continuity and a few running gags, there’s no need to start at the beginning.
This isn’t a “best of” list. Rather, these are 10 episodes that represent the things that Seinfeld did particularly well—including a couple with iconic punchlines and catchphrases that will get you in with the cool crowd, circa 1995.
Probably the most difficult step in the dev career is to jump from simple CRUD-like projects in the early years into some senior-level stuff with bigger architecture and a higher level of responsibility for the code quality. So, in this article, I tried to list the questions (and some answers) to think about, when working with large(r) Laravel projects.
This article will be full of external links to my own content and community resources, so feel free to check them out.
Disclaimer: What is a LARGE project?
First, I want to explain what I mean by “large”. Some people measure that in the number of database records, like million rows in users table is large. Yes, but it’s a large database, not the Laravel project itself.
What I mean by a larger project is mostly the number of entities to manage. In simple terms, how many Eloquent Models your project has. If you have many models, it usually means complexity. With that, as secondary measurement numbers, you may count the number of routes or public Controller methods.
With the scope of work this big, there are usually multiple developers working on the project, which brings the complexity to manage the codebase.
Also, a third non-tech feature of a large project is the price of the error. I would like to emphasize those projects where your inefficient or broken code may cause real money to be lost: like 30 minutes of downtime in an e-shop may lose $10,000 to the business easily. Or, some broken if-statement may lead real dozens of people to NOT place the orders.
So yes, I’ll be talking about those large projects below.
1. Automated Tests
In smaller projects, there’s usually a smaller budget and a stronger push to launch “something” quicker, so automated tests are often ignored as a “bonus feature”.
In larger projects, you just cannot physically manually test all the features before releasing them. You could test your own code, yes, but you have no idea how it may affect the old code written by others. Heck, you may even have no idea how that other code or modules work because you’re focused on your parts of the application.
So, how else would you ensure that the released code doesn’t cause bugs? Quite often a new code is just a refactoring of the old code, so if you change something in the project structure, how would you be able to test that nothing is broken? Don’t fall into the mindset I call “fingers-crossed driven development“.
Also, getting back to the definition of a larger project – remember, the price of the bug is high. So, literally, your broken code may cause financial loss to the business. If that argument still doesn’t convince you to cover the code with tests, probably nothing else will.
Yes, I know that typical argument that “we don’t have time to write tests“. I have a full video about it.
But this is where you need to find that time. It involves some communication: evaluate the deadlines thinking about the time to write tests, also talk to the managers about what would happen if you don’t write tests. They will then understand and allow that extra time. If they don’t, it means they don’t care about quality that much, so then maybe time to find another company?
Now, I’m not necessarily talking about a mythical “100% test coverage”. If you are really pressured on time, pick the functions to test that are crucial for your app to work. As Matt Stauffer famously said, “first, write tests for features, which, if they break, would cause you to lose your job“. So, anything related to payments, user access, stability of the core most used functionality.
2. Architecture and Project Structure
Ahh, yes, a million-dollar question: how to structure a Laravel project? I even published a 5-hour course on that topic, back in 2019, and I still feel I only scratched the surface there.
The thing is there’s no silver bullet and a one-size-fits-all approach. No one can claim that, for example, all bigger Laravel projects should follow DDD. Even SOLID principles sometimes are busted as not the best for some cases.
But the problem is clear: as your project structure grows, you need to change something, and re-structure the files/folders/classes into something more manageable. So what are the essential things you should do?
First, move things into sub-folders and namespace everything accordingly. Again, the example from the Monica CRM is pretty good.
Then, make sure that your classes/methods are not too large. There’s no magic number to follow, but if you feel that you need to scroll up&down too often, or spend too much time figuring out what the class/method does, it’s time to refactor and move the parts of the code somewhere else. The most common example of this is too big Controller files.
These are just two pieces of advice, but just those two changes make your code massively more readable, maintainable, and even more testable.
And yes, sometimes it requires a big “risky” refactoring of classes, but hey, you probably have automated tests to check everything, right? Right?
3. “Fake Data” with Factories and Seeds
A topic related to the automated testing we’ve already talked about. If you want to stress-test your application features, you need a large amount of data. And factories+seeds are a perfect combination to achieve that pretty easily.
Just get into the habit of, when creating a new Eloquent model, create a factory and a seed immediately, from the very beginning. Then, whoever will use it in the future to generate some fake data, will thank you very much.
But it’s not only about testing. Also, think about the fresh installation of your application. Large successful projects tend to grow only larger, so you would definitely have to onboard new developers. How much would they struggle with the installation process and getting up to speed, if they don’t have any sample data to work with?
You will also probably need to install your application multiple times on various servers – local, staging, some Docker-based environments, etc. You can customize the seeds to run under the condition of whether it’s a production or local environment.
4. Database structure
Although I mentioned in the beginning that database size is not the definition of a large Laravel project, but database structure is a hugely important thing for long-term performance and maintainability.
Which relationships to use? In Laravel terms, should it be a HasOne? HasMany? BelongsToMany? Polymorphic?
Also, other questions. One larger table or several smaller ones? ENUM field or a relationship? UUID or ID column? Of course, each case is individual, and I have a full course on structuring databases, but here is my main short tip.
Try to ask your “future self” about what potential SQL queries will there be on these DB tables, and try to write those queries first.
In other words, think about the end goal, and reverse engineer the structure from that. It would help you to “feel” the correct structure.
If you have factories and seeds ready (notice the pattern of how the topics in this article help each other?), you would be able to easily simulate the future usage, maybe even measure A vs B options, and decide on which is the correct one. This moment is actually very important: changing the DB structure in the future, with a large amount of live data, is probably one of the most complex/expensive/risky changes to make. So you better make a good decision up front.
That said, you shouldn’t be afraid to refactor the database if there’s a real need for that. Move some data into a separate less-used table, change HasMany into Polymorphic, choose other column types, etc.
Just make sure you don’t lose any customer data.
5. External Packages and Laravel Upgrades
When you choose what Laravel/PHP packages to include in your composer.json, in the very beginning it’s pretty easy: just use the latest versions of everything, and make sure the package is useful.
But later, when the project is alive for a year or two, there’s a need to upgrade the versions. Not only Laravel itself but also the packages, too.
Generally, the framework itself has a pretty stable core, and the upgrades to new versions are relatively easy, should take only a few hours. Also, a service called Laravel Shift is a huge helper for developers who want to save time on this.
But the problem arises from the packages you use.
Pretty typical scenario: you want to upgrade the project to a new Laravel version, but a few packages from your composer file haven’t released their new versions yet to support that Laravel upgrade. So, in my experience, project upgrades are happening at least a few months after the official Laravel release, when the package creators catch up.
And, there are worse scenarios: when the package creator doesn’t have time to release the upgrade (remember, most of them do it for free, in their spare time), or even abandon the package. What to do then?
First, of course, you can help the creator, and submit a Pull Request with the suggested upgrade (don’t forget to include automated tests). But even then, they need to review, test, and approve your PR, so I rarely see that happening in real life. The packages are either actively maintained, or close to abandoned status. So, the only reasonable solution then is to fork the package and use your own version in the future.
But, an even better decision, is to think deeper at the time of choosing what packages to use. Questions to ask are: “Do we REALLY need that package?” and “Does the package creator have a reputation of maintaining their packages?“
6. Performance of everything
If the project becomes successful, its database grows with more data, and the server needs to serve more users at a time. So then, the loading speed becomes an important factor.
Typically, in the Laravel community, we’re talking about performance optimization of Eloquent queries. Indeed, that’s the no.1 typical reason of performance issues.
But Eloquent and database are only one side of the story. There are other things you need to optimize for speed:
– Queue mechanism: your users should not be waiting for 5 minutes for the invoice email to arrive – Loading front-end assets: you shouldn’t serve 1 MB of CSS/JS if you can minimize it – Running automated tests suite: you can’t wait for an hour to deploy new changes – Web-server and PHP configuration: users shouldn’t be “waiting in line” while other 10,000 users are browsing the website – etc.
Of course, each of those topics is a separate world to dive deep in, but the first thing you should do is set up a measurement and reporting system, so you would be notified if there’s a slow query somewhere, a spike in visitors at some time or your server is near CPU limit.
7. Deployment Process and Downtime
In a typical smaller project, you can deploy new changes by just SSHing to the server and running a few git and artisan commands manually.
But if you have bigger traffic and a larger team, you need to take care of two things: – Zero-downtime deployment: to avoid any angry visitors that would see the “deploying changes…” screen, and collisions for visitors pre-post deployment. There’s the official Envoyer project for this and a fewalternatives. – Automatic deployments: not everyone on your team has (or should have) SSH access to production servers, so deployment should be a button somewhere, or happen automatically, triggered by some git action
Also, remember automated tests? So yeah, you should automate their automation. Sounds meta, I know. What I mean is that tests should be automatically run before any deployment. Or, in fact, they should be run whenever new code is pushed to the staging/develop branch.
You can schedule to perform even more automated actions at that point. In general, automation of this build/deploy process is called Continuous Integration or Continuous Delivery (CI/CD). It reduces some stress when releasing new features.
Recently, the most popular tool to achieve that became Github Actions, here are a few resources about it:
But it’s not only about setting up the software tools. The important thing is the human factor: every developer should know the deployment process and their responsibility in it. Everyone should know what branch to work on, how to commit code, and who/how closes the issues. Things like “don’t push directly to the master branch” or “don’t merge until the tests passed” should be followed on the subconscious level.
There are also social norms like “don’t deploy on Fridays”, but that is debatable, see the video below.
8. Hardware Infrastructure for Scaling
If your project reaches the stage of being very popular, it’s not enough to optimize the code performance. You need to scale it in terms of hardware, by putting up more server power as you need it, or even upsizing/downsizing based on some expected spikes in your visitor base, like in the case of Black Friday.
Also, it’s beneficial to have load balancing between multiple servers, it helps even in case one of the servers goes down, for whatever reason. You can use Laravel Forge for this, see the screenshot below.
Also, don’t forget the scaling of externalservices. There are separate infrastructure hardware solutions to power your File Storage, Queues, Elasticsearch/Algolia, Socket real-time stuff, Databases, etc. It would be a huge article on each of those areas.
There are so many various tools out there that I can’t really recommend one, in particular, everything depends individually on your project needs, your budget, and your familiarity with a certain ecosystem.
The obvious server-power leader of the world is Amazon with their AWS Ecosystem, but often it’s pretty hard to understand its documentation, there are even explanation websites like AWS in Plain English.
Also, there’s a relatively new “player” in town, called serverless. It became a thing in the Laravel world with the release of Laravel Vapor – a serverless deployment platform for Laravel, powered by AWS.
Probably the best resource to get deeper into this whole scaling world is the course Scaling Laravel.
9. Backups and Recovery Strategy
Everyone probably knows that you need to perform regular backups of your database. And, on the surface, it’s pretty easy to do with a simple Spatie Laravel Backup package:
And, of course, you need to automate it, like “set it and forget it”. But, an important question is have you tried the recovery from that DB backup, at least once?
You need to actually test the scenario: what if your current DB server totally dies, or someone drops the whole production database, and all you have is that backup SQL. Try to actually run the import from it, and test if nothing breaks. If there’s a problem with a backup recovery, you better know it before the disaster happens.
Also, it gets more complicated when you have multiple Database servers, replication, and also you want to not slow down your server while the backup is in progress. So you may tweak the process or use some database backup tools directly, even outside the Laravel world.
10. Bug Monitoring Process
Of course, the larger the codebase, the bigger probability of bugs happening. Also, when there are dozens of features, developers can’t test them all themselves, and even automated tests don’t catch all the possible scenarios and cases. Bugs happen to real users of the system, in the wild.
Your goal as a team is to monitor them and be informed when they happen. There are various tools to help with that, I personally use Bugsnag, but there’s also Flare, Sentry, Rollbar – all of them perform pretty much the same thing: notify you about the bugs, with all possible information that helps to trace and fix that bug.
But again, it’s not only about setting up the tool, it’s about the human factor, as well. The team needs to know the process of who reacts to what bug and how exactly: which bugs are urgent, which ones can be postponed, or totally ignored.
Also, the question “Who’s on duty today” is pretty relevant: if the bug tracking software notifies about something, who needs to get that message and via which channel? In our team, we use Slack notifications, and then ideally the situation should be fixed by the developer responsible for that part of the application which is buggy. Of course, in reality, it doesn’t happen all the time, but at least the team needs to know the time-to-react goals.
There’s also another part of the team: non-tech people. Developers need to be in touch with customer support people, and with managers, informing them about the severity and the status of the situation, so the “front-facing” people would talk to the customers accordingly.
11. Security
This question is kinda obvious, so I won’t explain it in too much detail. In addition to generally avoid getting hacked, probably the most important thing is to secure the personal data of your users – both from other users in multi-tenant systems and from the outside world.
Also, I recommend trying to hack yourself. Yes, I’m not kidding – ask some trusted friend/company from the outside to break into your app and do some damage. Heck, even pay for that – there are companies specializing in this area. Of course, you could try to do it yourself, but, as the author of the code, you’re kinda biased, and you probably wouldn’t try something unusual as a typical hacker would.
Finally, I’d like to express my happiness about the fact that we don’t need to explain the need for an SSL certificate anymore: with browser warning changes, and with free tools like Let’s Encrypt, there’s no excuse to not have https:// in your website.
12. Docs for onboarding new devs
The final point in this big article is about people. If you work on the project not from its first day, remember the day when you were introduced to it. Do you remember the feeling of installing everything, reading the docs, playing around with testing data, trying to understand how things work?
Now, imagine the mind of a new developer doing that on the current project, which is not much more complex. So, you need to help those poor guys, as much as you can.
I would suggest to even become that “new developer” for a day. When was the last time you tried to install your application, from the ground up? On a new computer or re-installed OS, for example. So yeah, try that, you may get a few unpleasant “surprises” to fix.
Things like installation instructions in Readme (maybe even with Docker images), comments in the code, making the code “clickable” in the IDE, understandable messages in git commits – all of that should be taken care of. And, remember when we talked about factories and seeds? Yes, that applies here, massively.
By the way, there are tools to help you, like this Readme generator.
And it’s not only about totally new developers – the same may happen to any existing team member who needs to fix something in the module that they hadn’t seen before. Any help is appreciated.
Your Thoughts?
What do you think about these 12 questions? I tried to provide short comments and external links, but obviously, it’s just an overview. Would you add any more questions to this list? Or, maybe you have a particular question you want me to expand on, in future articles/videos? Shoot in the comments below.
Just as each workday is a little different, the same can be said about digital projects. Some digital projects are big and require large teams, months of collaboration, and brand new everything to bring them from beginning to end. Some come and go in a matter of weeks and may require a single developer and little oversight. And then there’s everything else left in between. Not to mention clients, partner agencies, the other projects your team is working on, bugs that are about as easy to catch as an actual fly, timelines that won’t slow down for a single second, and a hundred other things that pop up—unexpectedly and not—from the first kickoff meeting. So what’s a project manager to do?
1. Communicate!
You’ve heard it before. There’s no such thing as overcommunication. But what does that mean? Does it mean relaying every moment in your team’s working day? Nope. Does it mean answering client questions with monosyllabic answers? Also, nope. Does it mean staying in touch with intention, asking the right questions and using your experience to anticipate problems that are lying in wait? Most definitely! That means discussing your team’s milestones and whether you’re on track to hit them, relaying those questions (there’s no such thing as a bad one, by the way), and figuring out your work plan. Video, chat, email, carrier pigeon, whatever your mode of communication is, keep it open and keep it clear.
2. Plan!
If a tree falls in a forest, does it make a sound? Of course it does. Squirrels have ears, after all. If a project doesn’t have clearly defined goals, can it possibly succeed? Luckily for us project managers, we can get started on setting concrete goals once contracts are signed and approved. At this early stage, we can take advantage of the client’s excitement (our team is about to start making their business vision a reality) while setting manageable expectations that are easy (enough) to shift as the project takes off. To do this, set your dial to the “direct” setting. For example, I’d suggest asking ‘What’s your number one goal for this project’? The answers to these questions will help you create a to-do list while building the foundation for success for all your team members. And that includes you!
The more those goals are defined with specifics, the easier it is to have a vantage point for all decision-making as the project evolves.
3. Prioritize!
Now that we have those oh-so-specific answers to our very direct questions, it’s time to prioritize them. Much like any thorough checklist, clients often come to the drawing board wanting EVERYTHING ALL AT ONCE. This is when the art of managing expectations comes into play. To help set expectations throughout any project, it’s helpful to reach early alignment on the absolute top priorities. Don’t be afraid to dig deep and have hard conversations. This is not a “this or that” conversation but is establishing a baseline that we can add to later. This is when we stop being polite (well, not really) and start getting real by figuring out what stays on the to-do list and what moves to the backlog.
4. Take notes!
Let us never give a woeful sigh that says “I didn’t write it down.” Write. It. Down. It’s more than helpful to take notes during conversations with your team–with any client, it is a necessity. There’s just so much to forget in a moment’s time, much less an intense, hour-long conversation with anyone. As an added bonus, when you take good notes you can then share any action steps with the client after group discussion. That way, everyone has a frame of reference to point back to, and conversations never rely on a distant memory.
5. Have an opinion!
Sometimes (all the times?) it’s scary to disagree with a client, but at the end of the day, the client has hired you for your expertise; it’s important to express your opinion about how to best proceed and back up that opinion with your reasons as to why. It may be as simple as spreading the knowledge that QA should be done “early and often” to help ensure there aren’t big gaps left at the end of a project. Not only are you showing your bona fides, you’re making sure your team has a voice even when they’re not at the table.
6. Set agendas for meetings!
Not all coffee is tasty, and not all meetings are good. Understanding that is the first step to a successful meeting. The next step? Agendas. A written agenda for any meeting helps you keep the meeting focused on its goals, and helps those joining know what to expect and how to come best prepared. Nothing is worse than showing up to a meeting that could have been an email, or showing up to a meeting only to learn for the first time you are supposed to present. Yeah… Don’t surprise your colleagues and clients. Try instead to use meetings as an expected opportunity for dialogue and not a statement of facts. Outline topics of conversation in your agenda, share it beforehand, and if it’s helpful, give the topics time constraints.
For example, consider a scenario when you’re showing a demo of work to-date. Rather than just simply sharing all progress, you can build excitement by talking through only 1 or 2 key product features while setting time aside to discuss initial feedback and any concerns, and sending the rest of the work after the meeting. During the meeting, you might ask, “Is anything unclear from the user experience?” Or verify, “Should the call to action really go there?” The bottom line is that consistently providing written agendas that outline the main goals/topics of conversation helps everyone understand what to expect each time and sets everyone up for success.
7. Document!
While you’re busy making notes, always make sure to capture those project decisions along the way. Think of it as a mutual point of reference for you and the client. Right about now, you might think, “But, wait, Jeanne, how could anyone forget a decision that was made together?” To which I reply, “Without documentation, did it happen, like the tree falling in the forest?” Even the shortest projects have numerous meetings. Moreover, every day will have off-the-cuff convos, casual Slack exchanges, decisions relayed by other team members… well, you get the picture. Medium story short, the more we document these decisions in a single place that both you and the client can refer to, the less likely wires will get crossed down the line. This is where your handy project management software really earns its salt.
At Tighten, we often like to document decisions in a shared Slack channel with the client, so everyone on the team has the opportunity to provide input and stay up-to-date.
8. Be flexible!
We all learn differently, and the more flexible we can be for the client and each other, the greater opportunity we have to create conditions for a successful outcome where everyone wins. This might mean using different tooling on some days because the client’s team is more comfortable with it. Or it might be something as simple as remembering to keep an open mind as more, and new, information becomes available around project strategies. There is no one correct way, and the more empathy we give to one another, the better.
9. Leverage your team’s strengths!
Of course the team will work collaboratively, but one extra helpful thing is honing and elevating the many strengths of our team members. We all have different strengths, and the more we can lean on each other, the stronger the project will be. Those strengths could be familiarity: a problem someone has solved on numerous occasions. It might be someone who can speak with helpful authority on a particular development quirk. Or it could be as simple as a fresh perspective on a tricky problem. Whatever the case may be, lean into one of our overriding themes of the day: Just ask!
10. Celebrate along the way!
Active feedback and celebration are helpful to a project’s success, especially in remote environments where in-person interactions simply don’t take place. That said, don’t wait until the end of the project to celebrate successes. Don’t focus only on the big milestones. Mindfully appreciate all the work the team puts in each day and call out the small wins along the way. You’re all in this together.
11. But what about project management software!
At Tighten, we like simple, repeatable systems, and tools that support doing them well. We enjoy Trello, GitHub, and Slack, but this one is up to you! Do what works best for you and the team, understanding that more often than not there is no one single solution—no matter what the software advertisements tell you.
There you have it. 11 simple steps for successful digital project management of any size. If you have favorite tips or tricks, we’d love to hear them!
