More from Tinloof - Blog
In this article, we provide a comprehensive guide to designing an intuitive and universally accessible carousel for any web project. Outcome Carousels in UI are practical interactive elements that efficiently display images or content pieces without taking up too much vertical space.
Insights into how Tinloof measures website speed with best practices to make faster websites.
At Tinloof, we aim for seamless and efficient design handoffs, drawing from our experience completing dozens of projects. Our ultimate goal is a "0 questions asked" handoff, akin to an improved IKEA assembly experience. In this article, we'll explore the three core sections of our Figma files: Design System, Blocks, and Pages. We'll also discuss our feedback process and highlight useful Figma features.
Tinloof focuses on key principles to consistently create pleasant and practical designs. We're not tied to any specific style - Swiss, Linear-like, neobrutalism, a certain typography or color palette. Instead, we stick to basics that make our process smooth, please our users, attract business, and keep our team happy.
Context Like many businesses operating online, we at Tinloof decided to explore SEO to attract more leads. Seeing the numerous SEO gurus on LinkedIn and Twitter, one might think it's worth a shot to try this approach, hoping to strike gold when search engines place your website at the top of the results page.
More in programming
After pushing towards the goal for some time, I finally shipped 100+ pull requests to production in a week, reaching 115 the week of November 9th. Because I’m vain, I’ll cook the numbers slightly to take the highest seven day period rather than calendar week, which up to this point peaks at 170 merged PRs. Of those 170, 17 nuanced and UX-centric PRs were written on a harness running on my laptop, and the remaining 153 were written on Imprint’s internal cloud harness called fleet. About 150 of these were true production PRs that continuously deployed to production (but didn’t necessarily release), and the other 20 were skills, internal tools, and so on. Many people in the industry are shipping far more PRs than I am, but I think it’s interesting to discuss how I got here specifically, especially in the context of a fintech company shipping software that’s critical from reliability (members’ lives depend on rapid access to credit), security (members require their credit is kept safe), and revenue (our partners rely on our cards to accelerate revenue) perspectives. We’re also six years old, so we were not built from zero to be an AI-native company, but have instead had to retrofit our approach at each step along the way. The mental model we worked Fundamentally, productivity with AI tooling comes down to optimizing the same software development loop we’ve been optimizing since I entered the industry. It’s just that we have many new techniques to optimize that loop, and many things that were previously unattainable for most companies (e.g. formal verification) are now attainable for anyone willing to make a persistent attempt. At each step in pushing from 5-10 PRs per week, to 20 per week, to 40 per week, and now to 80-100 per week, it’s been optimizing a new place in this model. At first the problem was lack of structured issues that the harness could use, then it was a low quality of generated pull requests, then it was slow approvals, then it became running out of straightforward work, and so on. Working the model With the model at hand, let’s talk through the order of the specific problems that the model revealed in our workflows, and how we’ve solved our bottlenecks: Modernizing our practices for deployment (CI/CD) and release (feature flags) (December/January ‘26). I’ve written about these steps before, so I won’t belabor them, but we were very bottlenecked on deployment and release until we moved to a standard, modern process for both. Without this work, we would have never hit the subsequent bottlenecks. Reducing context poison in our knowledge base (February ‘26). After our CI/CD improved, we started to recognize the need to surface our RFCs and PRDs into the context window of the agents developing our software. We quickly realized that much of that context was wrong. Where possible, we moved context directly into our repositories themselves (e.g. terraform to manage cloud configuration so the harness can see the full networking and orchestration setup in addition to the code running on it). We also refactored our Notion documentation to ensure every document was largely accurate, and in particular to eliminate wholly inaccurate documents from our knowledge base. This has been running since, reducing the risk of inaccurate information surfacing in context windows, and one of our managers (ty Andrew) has subsequently gone further, adding loops that update stale documentation in our knowledge base based on code changes. Providing structured issue management with Linear (June ‘26). I’ve also written about this one before, but we had significant friction getting into a unified tool holding all of our issues, and which made it easy to add new issues via a UX, Slack, and agents. We moved the whole company from Jira to Linear in June. Supporting orchestrated agents instead of running only on a laptop (July to October ‘26). Even with folks running many agents locally, we found two problems. First, there were more tasks than they could work on simultaneously without losing track of them. Second, there were more grooming tasks than expected, for things like dealing with new merge conflicts, responding to comments on pull requests, and dealing with CI/CD failures. We built out the fleet cloud harness to make it possible to run work in the cloud, when your laptop was closed, and triggered by events rather than an emergent system composed of dozens of laptop-local loops. Building the first pass of this was quick, but it took longer than expected to get to a level of polish that drove substantial adoption. It had to not only be reliable, it had to be better than the local experience to convince folks it was worth moving. The biggest places we passed that bar were concurrency (run as many as you want), decoupling from laptop (trigger and respond when laptop is closed), MCPs and tools available by default (don’t have to maintain or manage the integrations, especially relevant for non-engineers), and reacting to events rather than polling (always and immediately pick up new comments or build issues). Standardizing around an internal MCP to reduce human actions and IT burden (September ‘26). Earlier in the year, we rebuilt how we handled configuration into a unified data model managed through a single UX. This substantially eased management, but it still required human involvement for checking and updating values. We introduced an internal MCP that offers all the same functionality as that internal UX, while doubling down on that UX’s existing pattern: anyone can propose a draft that gets automated review for safety, but approval of changes is managed via a series of task-specific roles only available via the UX. Now an agent can pull down all values, and can propose updates, but every update remains reviewed and approved by a human with full context. This has substantially increased the ease of management while preserving correctness and safety. This internal MCP also means that most folks can rely on it, rather than the numerous downstream per-tool MCPs provided by vendors, for their day-to-day work. For example, we were unlikely to provision everyone onto our feature flag tooling, but now almost no one needs that access since they and their agents can access the data directly. This tooling is also available in our Slack agents which has largely eliminated the prior access gates (and limited human expertise) that interfered with diagnosing what might have driven a shift in behavior. Slow approvals on pull requests (October ‘26). As the volume of pull requests started to creep up, we (like everyone else in the industry) started to run into friction getting approvals. We’ve adopted two primary mechanisms to address this. First, we’ve used the small-change approach to streamline a subset of clearly safe changes. Second, we allow some changes made using our cloud harness to be approved by a single person. Both of these have reduced load, with about half of our changes now going through one of these mechanisms, but I think the idea that “approval” was the bottleneck was actually a bit of a misread on the situation: the bigger problem was the quality of the pull requests wasn’t high enough, which we started to work on next. Using verification to increase confidence in changes and ease review (October ‘26). As some approvals got faster, we found that our agents were still frequently generating pull requests that were hard to approve either because they didn’t fully verify their work, or because it was ambiguous what they had verified. In this case, the bottleneck wasn’t pull request approval, but instead generating approvable pull requests. To address that, we adopted pieces of poteto’s pstack to structure how we verified changes. I wrote about adopting the verification pattern previously, and we’ve since then also adopted pstack’s formal verification approach. At this point, I largely review verification files and from that decide whether I need to review the pull request in more detail. Running out of easily addressable work (October-November ‘26). As the quality of verifications increased, it became increasingly fast to verify work. Fast enough that I started to run out of easy work to do. There was still hard work to do, but that required some focused time to set up, and I was pretty sure there was still a lot of easy work out there, it just wasn’t getting logged as structured issues that we could work. We solved this bottleneck in several ways: loops to maintain verifications, review recent launches for performance and problems, check for new errors, prune stabilized feature flags, and so on software-factory pattern is a subset of the loop pattern, and has been effective at generating ongoing work on a well-scoped problem. Getting this set up for a specific area requires some focused attention, as does triaging its suggestions, but it’s very much like having a mid-level engineer proactively thinking about a problem. There are a lot of problems where that’s quite valuable events that provide new work. For example, security findings from static analysis, new errors showing up in error logs, customer concerns surfaced in customer support calls, and a distress tool provided to all of our harnesses that allows the harness itself to flag problems to triage I’m sure we’ll keep iteratively adding more of these. Many of these are categories of work that we’ve trained ourselves to stop thinking about because it’s valuable but has an insufficient return-on-attention to actually do… but now that’s not true. All this sort of cleanup work is eminently doable. Improving orchestration with /my-open-work (November ‘26). It seems too small to say, but the major unlock at this point was that orchestrating our issues and cloud harness had gotten too burdensome given the volume of concurrent tasks, and the final major breakthrough that got me to over 100 merged PRs was a skill I run once or twice a day to triage my open work. This can go from autonomously pushing the cloud harness to recover from a failure mode, to scheduling new work onto the cloud harness for new issues, to stepping me through open questions that benefit from human input, to identifying the changes that require my personal review. I imagine in a month or two this will be an automated process that happens for all of us every morning, but we’re still feeling through the nuances of doing it by hand. Accelerating hard work (November ‘26 - ?). The biggest problem we are dealing with now is figuring out how to accelerate hard work. The sort of work that requires deep thinking about partner needs, member experience, fintech nuances, and how the industry is moving. The bottleneck a year ago was development bandwidth, but that’s not true today, and we’re experimenting with the Explorer pattern to allow teams to take advantage of our newfound iteration speed. Are we done working the model? No, of course not. As things stand today, our three biggest bottlenecks are: Accelerate our ability to complete hard work. I suspect there’s no end to the ways we’ll benefit from this kind of work Increase verification coverage to be able to verify even more complex and nuanced pieces of work. As a narrow example, our cloud fleet often creates one-off shims to manipulate feature flags for verification, but we should really provide a reusable tool for it to simulate modifying feature flags to ensure it can easily do so Improve our ability to facilitate orchestration without human involvement. For example, we should keep improving on our /my-open-work skill, and have it run automatically and push updates for each of us every morning Based on our latest progress, I’m certain we’ll make substantial progress over the next month, and even more by the end of the year. These do feel like enduring points of optimization, but the bottleneck has continued to move over the course of the year, and I’m sure it’ll move again. CI/CD is dead! Code review is dead! Etc! There are a lot of narratives about how CI/CD is dead and so on. Maybe that’s true, I guess? But I don’t personally see a ton of evidence of those sorts of claims yet. Maybe as one gets to 1,000s of PRs per week for each engineer, you reach that point, but I’m a little bit skeptical that it is the expected outcome for the sort of software that Imprint is working on, which has substantial correctness, security, compliance, and partner integration points, along with needing to remain comprehensible to the human beings who rely on the software every day. This isn’t a hard refutation–best-practice is shifting so quickly these days that I suspect everything we are doing today is long-term wrong–but I’m not a buyer on these memes yet. Does merged PR per week matter? No, not really. Merged PRs per week is just a number that asks questions, not a number that answers questions. Many of the PRs I work on are objectively much simpler than the PRs that our senior-most engineers work on. I don’t think that disproves the fact that merging 50x our p50 PRs/week/engineer from a year ago is a fascinating sign of how the fundamentals of software development have changed.
Helping Scout focus and remember
tl;dr: the Explorer Pattern is one individual or team building a functional implementation that minimizes cross-team and cross-functional impacts as much as humanly possible, and then reconciling the details with other teams after that prototype is completed, accepting that this approach can require very substantial rework to that initial development. Why write this? Imprint previously called this the “Tech-led” or “Engineering-led” development model, but it’s pretty unclear to folks what that means. This writeup provides a more defined term, the “Explorer Pattern”, and explains in more detail how this works. Why do we need to adjust the way we work? Before 2026: Code is expensive, and we design process to minimize implementation and rework In and after 2026: Writing software is extremely cheap, but it’s a wider phenomenon: generating output is effectively-free across many dimensions. Code is nearly free — if we have appropriate constraints. Designs are nearly free — if they follow patterns. Analysis is nearly free — if we’ve instrumented things properly Reworking software is extremely cheap. Historically industry has optimized around avoiding engineering rework because engineering was the highest cost / narrowest constraint. In many companies this was interpreted as writing code being the constraint, which was never true, but many common practices were designed as if that were true (e.g. bringing engineering into problem-solving late “to protect their time”) Working on the system is much more effective than historically if we get automated integration and feedback loops right, e.g. not improving a one-off design but improving the design system. Any place where improving the higher-leverage process is slower than solving the one-off is a bug in our process Explorer Pattern: primary-and-replicas metaphor The easiest metaphor to think about the Explorer Pattern is database replication. Databases like MySQL and PostgreSQL have a primary database, where writes are performed. Every write is verified at that point, and once it’s verified, you know that the writes will flow downstream to various secondary replicas. Those downstream replicas can be delayed but they can’t be wrong because writes are verified upstream. (I’ve resisted the desire to talk about the CAP theorem.) A different model for database design is that used by Dynamo or Cassandra (or MongoDB to a certain extent), where you have a replica set, and have to get an acknowledgement from the majority of the replica set for a write to be strongly consistent. This is a very reliable setup, because it means you can tolerate losing a node, but it also introduces inconsistencies, and on a fixed amount of hardware they tend to be much, much slower than running a primary-secondary setup (or rely on bad performance metrics that don’t fsync to disk to create the illusion of throughput). The Explorer Pattern is the former primary-secondary model, where the vast majority of the work is done by the working individual or team. This makes all work internally consistent because it’s passed through the same small group. It doesn’t, however, mean that the work is perfect. For example, you can always insert data that meets the table’s requirements but is still inherently wrong (e.g. 200 is a valid integer, but it doesn’t mean that my credit limit was supposed to be 200, that depends on the surrounding application logic). Other teams become aware of the changes downstream, not synchronously upfront, and it’s instead the working group’s responsibility to both rationalize approach and create visibility into their work for other teams to engage in a non-blocking fashion. Example: Support for Financial Aggregators A concrete example of this practice at Imprint was rolling out financial aggregator support, e.g. allowing folks to connect to their Imprint powered accounts via Plaid. This has always been something folks want, but it’s particularly important in the realm of agentic commerce where more folks’ agents are analyzing their financial state for them. For this project, one of our engineering leaders (Ron), built the first pass of the feature at a low-burn while understanding the shape of the problem in a private alpha. He chatted through some of the details periodically to keep other teams aware, but it was a bit of a side project. However, once he found the full shape of the problem and had implemented a full solution, we cut the replica-lag across teams down to near-zero, identified and ran through the small number of remaining issues, and shipped it. Like many of our projects this year, it was never officially on a roadmap, and shipped a quality feature that our members have wanted for some time. How to follow the Explorer pattern The rough rules for following the Explorer pattern: Know your goal and sponsor: every initiative ultimately has to have a specific outcome it’s pursuing and a sponsor who’s bankrolling that pursuit. This doesn’t always need to be explicit, especially for smaller projects, but once a project goes beyond ~3 weeks of effort, if you can’t very explicitly identify who the stakeholder is sponsoring your project and they would not enthusiastically agree, then you are likely closer to “lost” than “exploring” Small working group is small: at most 5 people, and preferably smaller. Everyone in the group has to keep the entire project in their head for as long as possible to detect problems and opportunities Small working group is flexible: folks in small working groups have to “find a way to yes” rather than “find a way to no”. Exploring is about uncovering the fundamental shape of a problem rather than pretending we know the fundamental shape Publish progress in a public channel: explorers have to report home with the progress they are making so others are aware. This is both a Linear Project and a Slack channel. Make the narrowest viable changes to what already exists: when we introduce unnecessary changes, we invalidate others’ mental models about how the world works. When we haven’t made those changes with care, we’re not only invalidating others’ mental model, we are creating the expectation that we’ve done it very intentionally for a good reason, which has a chilling effect on others improving them later, which is very expensive, whereas the Explorer pattern depends on being as inexpensive as possible Exercise good judgment to identify reasonable hypotheses: discard bad ideas immediately, and then filter the rest by trying to implement them as quickly as possible. Once you see the shape of the implementation, you can figure out which of the remainders are interesting Hold assumptions constant to avoid getting stuck: the only way to navigate complex ambiguous problems is to hold things constant, even when you know they are imperfect. For example, to do headcount planning we have to know our revenue, to know our revenue we have to forecast it, to forecast it we have to know the day that partners will go live next year. We don’t truly know any of those things, so just anchoring on a plausible guess to unblock us is much more valuable than trying to get them accurate. A little prework is useful, but a lot is just artificial precision that’s a distraction from progress Hold space for being totally wrong: when we move fast, with low information, we always find the way out, but often it’s not the way out we anticipated when we got started. Being open to throwing it all away, and starting a second, third, fourth time Ship all the way to production behind a feature flag: features and products move fast when we get the pieces working every step from frontend to backend to data pulls. This is the first step of exploration. Just make sure it’s behind a feature flag that’s only enabled for internal folks!
Comparing two different ways of work and working environments.
I own an old, cheap TV. It has no Internet connection, no fancy smart features that make you want to install a Pi-hole, and no ask-me-again-later updates. However, it is connected to my own desktop computer through an HDMI cable, so I can watch movies and TV series from the couch. Setting it up used […] The post Making a dumb TV just smart enough appeared first on Quentin Santos.