As a still-small-and-nimble organization, speed is our greatest advantage over the incumbents in our industry. But, if we don't execute extremely well and deliver extremely high-quality products consistently, we won’t have any staying power. Because of that, we're obsessed with breaking large problems into small, meaningful chunks. Our quality bar is exceptionally high and we are willing to sweat the minor details.
We are conscious of our technical debt and regularly invest time and energy into the foundations of our codebase. We design extensible, solid, foundations. We make strong use of TypeScript’s type system to prevent bugs.
Our platform is supported by different layers of automated testing via continuous integration, such as unit testing, functional testing, integration testing, smoke testing, and thorough linting and formatting. We rely on this automated tooling to keep codebases consistent, so we can focus on the foundation and mechanics of each feature during code reviews.
We strive for simplicity. When contributing code, Asana engineers always ask the question, “Could this be simpler?” Striving for the simplest, most viable solution requires time and effort up front, but it always pays off in the long-run.
Simple solutions are easier to understand, especially as our codebase grows, and engineers often spend more time reading than writing code. Having code that’s easy to reason about enables them to spot bugs faster and make modifications with confidence.
By reducing complexity, our team is able to create a more reliable, maintainable, and testable application, and therefore a better experience for our users.
46 Open Positions
Automated financial management to save, plan, and invest all in one place
Palo Alto, CA or Remote (US)
They cover code consistency, using data to make decisions, technical leadership, learning from our mistakes, focusing on automation and developer productivity, writing safe, well tested and monitored code, and shipping small changes quickly and continuously.
Additionally, we have an org-wide proportional investment policy that provides the opportunity to prioritize work that helps improve the codebase and developer productivity. While we value urgency and moving quickly, we also favor doing things the right way as opposed to the fast way.
13 Open Positions
As a team, we embrace automation, consistency, and simplicity:
Our tech stack is optimized to be modern and easy to pick up, but not excessively flashy. We value new technologies when the benefits are clear, but being pragmatic is our number one priority. Some of the tools we use include:
Central to our values of high integrity and a sustainable work culture, we invest in keeping tech debt to a minimum and maintaining a high quality code base from the beginning. Not only does a high quality code base keep our on-call rotation reasonable, but it also limits the time we spend fixing broken or flaky parts. This means we can focus the majority of our time on feature development for our customers. To ensure a high quality codebase we:
Every day, more and more patients, clinicians, and researchers rely on our data APIs being available, our algorithms processing continuously, and every point in between being 100% secure.
We measure thrice, and cut once. We require an architectural design document for every feature we build, together with a risk matrix to help predict things that can go wrong. We also require code leaving a branch to be production ready, which means it comes with tests and a monitoring strategy. It's more work, and it does mean it takes a little longer until we write that first line of code, but when we do, there are no surprises and it more than makes up for the time spent up-front.
In terms of the staples, our team actively uses and gate merges on peer-reviewed pull requests, lint and static analysis checks, unit tests, and integration tests. We invest heavily in CI/CD automation, 100% of our infrastructure is peer-reviewed code, and we <3 observability!
All this isn't to say that we don't have tech debt. However, our team's approach is to have tech debt that we choose consciously and strategically as we design each feature. Each quarter, we allocate 70% of engineering hours to new feature development and 30% to our internal needs.
As an engineer at HumanFirst, you will spend most of your time writing and interacting with code. Because of this, we spend a lot of time making the code an enjoyable place to be. We understand that a code base is more than the raw bytes that do the work; we place a strong emphasis on documentation, testing, readability, tooling, and extensibility. We have a full set of unit, integration, and end-to-end tests that give us an average of 90% coverage, with some projects reaching 100%. Our APIs have fully interactive documentation (from endpoints to parameters to responses) and our frontend components are documented both in their appearance and behavior using Storybook.
Additionally, we regularly examine pain points and work toward refactoring for better usability. We keep an account of any tech debt we acquire, and make sure to allocate regular time to pay it off. Our ultimate goal is to make sure the structures we have in place help, rather than hinder, both you as an engineer and our ability to serve our customers’ needs.
Increasing code quality is a high priority for us. We are given the capacity to do things right, even if it takes longer. Everything is a trade-off: if we can spend a week fixing technical debt now to save us time in the future, then we’ll do it. We’re striving to increase test coverage across our whole codebase.
By using feature flags inside of the product, we can ensure that new customers use the latest and greatest features, while leaving older customers on stable grounds without changing things. Our Customer Success team actively works to migrate customers to the latest version of features so they can be deprecated and removed from the code. Examples: client website migrations, new API explorer, and new markdown parser.
First and foremost, having a high quality code base enables us to write new code faster. With a lot of the complexities abstracted, we leverage our code in order to develop more quickly. We utilize controllers in our codebase, which allow us to do operations in Doppler, and each controller has baked in permissioning, security, analytics, bug reporting, and other features so we are secure by default.
While there are many advantages to having quality code, it also isn’t a choice for us. We store incredibly sensitive data for customers, so having high quality code is really a necessity for our business. We’ve gone through two penetration tests, conduct rigorous code reviews, ensure all core flows have end to end tests, and use a dedicated staging environment for QA.
Perhaps this is somewhat unique to Doppler, but we don’t have to compromise between speed and quality. We’re a productivity tool that makes you more secure, and generally speaking, if you’re more secure, you’re more productive. By prioritizing reusability, we’re able to turn OR operations into AND operations.
One of the things we love about working at LaunchDarkly is that we are making life better for software teams around the globe. Our “Product Delivery” Team is made up of engineers, product managers, and designers. We have four Product Delivery values:
We approach hard problems with an engineering mindset. And we're not afraid of big challenges.
Our engineering team is composed of veterans from the top technology companies in the industry. We built our system right the first time and it has scaled for years as a result. We have been able to meet the challenges that exponential growth of our product has brought with it, and much of this has rested on our foundational decisions.
We invested heavily in a modern, distributed flag delivery network – even when the company was small. We handle our infrastructure as code. We build and deploy on AWS and have made extensive use of platform capabilities (AWS Lambda, Kinesis). We want our team to focus on high-value problems and leave the undifferentiated heavy lifting to others.
All of our core services are written in Go, which strikes a great balance between performance and ease of development. All of this gives our customers the ability to control their software in product and make critical changes in situations when milliseconds matter. We work every day to give engineering teams just like ours new super-powers.
18 Open Positions
Angaza engineers have a strong bias towards clarity over complexity and simplicity over cleverness. We deliver deep, constructive code reviews; employ continuous integration and blue/green deploys; and prefer care over speed when it comes to production. Our platform is essential to our customers. As a result, we strive to build our engineering culture on a bedrock of quality.
Engineers have wide latitude to work across the entire codebase. We attempt to fix entire classes of bugs at a time. When mistakes do occur, we practice a no-blame postmortem culture.
1 Open Positions
Want to List Your Company?
Submit a team profile!
Select 8 Values
Contact me (Lynne 👋)
Qualify Your Values
Reach Thousands of Devs
Find Value-Aligned Candidates
Have Meaningful Initial Conversations
Don't Fill Roles, Hire Teammates
You can post as many job openings as you want.