Muamer Cisija is cofounder and president of Symphony, an AI-first software design and development company.
getty
In the first quarter of 2026, my company added 105 people to a company of more than 800, as engagements that started as single-team pilots were expanding across entire organizations within weeks.
I'm not writing this to claim we cracked some code. I'm writing it because scaling this fast taught us things we couldn't have learned any other way. Most of these lessons contradict the conventional wisdom about how you're supposed to grow a technology company.
The first thing you learn when scaling quickly is that your old process doesn't survive contact with urgency. We compressed our most recent hires to 16 hours from first conversation to signed offer. The key is not to lower the bar but to figure out what the bar actually is.
This is where most leaders get it wrong: They treat speed and standards as a trade-off. We didn't get faster by cutting the steps that protected quality. We got faster by cutting the steps that tested for proxies—the second screening call that reconfirmed what the first one already told us, or the panel round that existed to spread accountability rather than gather signal.
Instead of lowering the bar, compress the process by sharpening the bar to the few things that predict success.
What are those few things? Not AI experience. The tools change every quarter, and whatever someone learned six months ago is already half-obsolete.
What doesn't change is whether someone can break down a complex problem, build something that holds up under pressure, and—the one that matters most—whether they're genuinely curious about the technology. Not "I took a course" curious. "I stayed up until 2 a.m. building something because I wanted to see if it would work" curious.
Everything else we used to screen for was process theater.
Sorting people into those two categories is more straightforward than most hiring processes assume, once you stop asking what people know and start watching what they do. Give a candidate a real problem—something close to the work, not an abstract puzzle—and watch how they break it down before writing a line of code. Then ask the question that separates the two cleanly: What have you built that nobody asked you to build?
The second thing you learn is that you have to build your own pipeline. We run 50 interns at any given time through what we call our Future Experts program, an always-on internship model where people rotate through real engagements, working on real problems. This type of model can help you develop engineers who can operate in an environment where the playbook is being written in real time.
If you're building this type of model, a few choices matter more than the rest.
Make it always-on, not cohort-based. The moment you hire in cohorts, you're back to being caught short when demand spikes.
Put people on live engagements, because the learning that transfers doesn't happen in a sandbox. Pair every junior with a senior engineer on real work, since the playbook in this market isn't written down anywhere; it's passed from someone who's figuring it out to someone watching them do it.
Finally, measure the program by a single number: how quickly someone goes from joining to contributing on client work.
Hiring fast solves headcount, but not the harder problem: capability.
The difference between 20 people who get it and 500 who get it isn't a bigger version of the same challenge; it's a different one entirely. You can hire brilliantly and still stall, because the constraint shifts from getting people in the door to getting a critical mass of them to actually operate this way.
When AI adoption lives in a small team, the knowledge is concentrated. Two or three people hold the context, make the calls and push the work forward.
On a team of 500, this becomes a bottleneck. Every new hire queues behind the same few experts. We tried to fix that with the process before we had the right structure underneath. It didn't work: Process layered on top of unclear ownership doesn't create order; it formalizes the chaos and adds meetings to it.
You can find this in your own organization with one question: If your two most critical people went offline for two weeks, would the work continue, or would it stall? If it stalls, no amount of hiring fixes it. You have a concentration problem, not a headcount one.
The decision that made our scaling work was treating capability as everyone's job: Everyone experiments, not just engineers. If you're in business development, you need to know what AI can do, and not just in theory, but because you've used it.
"Everyone experiments" is only a slogan until you build the model that makes it real. Ours has three parts: access with no gatekeeping, so everyone gets the tools and standing permission to use them on their actual work; a low bar to start and a high bar to share, so people experiment on their own bottlenecks; and a path for the experiments that work to get resourced and become how the team operates.
The thing nobody tells you about scaling fast is that the learning is the product.
We didn't add 105 people because we had a plan set in stone. We did it because the demand was real, the signals were clear, and we'd rather build capacity slightly ahead of where we need it than scramble to catch up after we've missed the window.
This is not the moment to optimize your hiring process. It's not the moment to write the perfect job description or wait for the candidate who checks every box. The role changes too fast. The tools change too fast. The market changes too fast. It's the moment to hire people who can figure it out, put them close to the work and get out of their way.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。