We provide fractional CTO services that come with the support of an existing team. This
allows us to make progress toward your goals with minimal ramp up time. Our team can
take your startup from 0 to 10 or from 10 to 100.
Hire, train, and keep an effective technical staff.
Identify Needs
Job descriptions aren't easy.
Technical staffing must start with a clear understanding of technical needs and goals. Once we research
and understand your projects, goals, and technology roadmap, we use that understanding to define the
roles you need to fill and plan the right time to fill them.
Hire and Vet
The right person for the right job.
Selecting and vetting technical employees requires intimate knowledge of the requirements of the position.
We can help you find, interview, and vet the staff that you actually need.
Train
Help staff be effective.
Once the right staff is in place, it is a constant challenge to keep everyone up to speed. This
challenge is exacerbated by the extreme pace of progress experienced by a startup. We'll implement
processes to make sure no one gets left behind.
Reduce Turnover
Keep the right staff.
Keeping the right staff is as important as finding them. The average employee tenure for a startup
is staggeringly low. We can help you take steps now and in the future to keep the staff that you need.
Review
Ensure staff is effective.
Performance evaluation for technical staff requires a deep understanding of the work they are doing
and the needs of your team. We evaluate skill, growth, and team dynamics frequently.
Strategic and tactical
Set the right realistic goals. Define a roadmap to achieve them. Then do it.
Strategic
Define where and why.
We provide the technical know-how to help you define where your company is going and why.
Tactical
Define how.
Once we define where you are going and why, the real work begins. We'll help you determine how best to get
there and how to be adaptable along the way.
Adaptable
Overcome all roadblocks.
Deviation from the original plan is inevitable. We'll help you adapt to a change in course, get
back on course, and decide which approach is correct.
The emergency room
Fix the right broken things in the right order.
Identify
Figure out what is broken.
Processes, staff, software, and systems will all break at some point. We'll help you identify
what's broken and how badly.
Sort
Fix things in the right order.
Once you know what is broken, you must correctly determine when it should be fixed. We'll
help you fix problems in the most efficient order.
Heal
Don't fix symptoms. Heal disease.
We have the knowledge, skill, and experience required to discover and solve the root
cause of your problems.
How We Do Software
We're into elegant solutions to hard problems.
Well-Planned
Great code starts with a great plan.
We have the experience with diverse languages and technologies necessary to help
you choose the right language, framework, and storage system to achieve your goals.
With Standards
Keep everything nice and tidy.
Whether you are a starting a new project or revamping an existing application, we
can help you architect your software, standards, and processes to achieve
maintainability and increase productivity.
Scalable
Too much growth can hurt.
If your product is taking off and you need help scaling to meet the demand, we would
love to take some pressure off of your team. We have extensive experience designing
software that performs at scale.
Maintainable
Incomprehensible is broken.
If you can't come back in a month, quarter, or year and quickly modify existing code,
progress will eventually slow to a crawl. If it takes new hires months to become
productive, you are are burning money. We can help you avoid or mitigate pitfalls
that lead to problems later.
Future-Proof
What you do now must work later.
Predicting all future goals is impossible. It takes a lot of experience
and planning to avoid painting yourself into a corner. We have the requisite
experience.
How We Do DevOps
This site probably does DevOps better than yours.
Code-Centric
It all starts with code.
We start by understanding and optimizing code. Great DevOps starts with great code.
We are developers who understand systems, not the other way around.
Source Control
Keep track of that great code.
In this case we are using github,
but we can help you integrate our systems with bitbucket or gitlab just as easily.
Local Testing
Don't commit bad code.
We use docker containers to create disposable local environments that duplicate
production. They can be created, destroyed, and recreated in seconds. We love
automatic code formatting tools and quick running lint and smoke tests in
pre-commit hooks.
Automated Testing
Don't merge bad code.
Before pull requests are merged, they are tested automatically and peer reviewed.
For this site we use drone.io
to test, build, and deploy code.
Build
Automatic and interactive.
After testing, drone.io builds
docker images to be deployed to our Kubernetes cluster.
Deploy
Put code where it goes.
After code is built, it should go where it is supposed to. Tags beginning with
the prefix "stage-" are deployed to our staging environment and accessible
at a sub-domain that matches whatever comes after the dash. Commits tagged "www"
are deployed to the production environment. Tag based deployments make testing
and reverting a breeze.
Notify
The team knows what is going on.
We use integrations and custom bots to make sure that our slack channels are updated
with pertinent information about anything that goes right or wrong in our DevOps processes.
How We Do Systems
Code is king.
Code-Centric
It all starts with code.
We start by understanding your code. Great infrastructure design requires an intimate
understanding of the current and future needs of your software.
Balanced
We walk the tightrope.
Balancing developer control of the environment that their software runs in with the
stability and security requirements of well built infrastructure is a tightrope
we know how to walk. We can show you how.
Scalable and Redundant
Requirements, not suggestions.
Scalability and high availability are requirements, not suggestions. The days of
monolithic systems running monolithic software are over. Good riddance. We will
design systems that are fault tolerant and horizontally scalable on whatever
budget you have to work with.
Cloud-Based
Scaling out should be easy.
We've built and managed many racks of physical hardware. We don't recommend it. We prefer
AWS and GCE. But we have worked with an assortment of cloud providers. We have the experience
required to help you choose the provider that best matches your needs.