Maksym Bardakh6 min read
Reducing the Cost of Context Switching Across Apps
Why moving between apps and tasks carries a hidden cognitive cost, and how software can reduce the friction of switching for the people who use it.
Writing
Notes on building software
Essays on design, engineering, and product decisions — written by the people who build our products. Filter by topic, or browse all 100.
100 articles
Maksym Bardakh7 min read
Trust as an Engineering Property: Security, Transparency, and Defaults
Why trust is built through engineering choices, not marketing: how secure architecture, transparent behavior, and good defaults earn it.
Maksym Bardakh6 min read
How We Decide Whether to Build a Feature
The questions a small studio asks before building anything, turning feature decisions into a deliberate test of purpose, cost, and fit.
Mykhailo Boichuk7 min read
The Maintenance Mindset: Software That Lasts a Decade
What it takes to build software that remains maintainable for ten years, where most cost lives after launch and clarity beats cleverness.
Maksym Bardakh6 min read
Designing Trust Signals on a Product Website
How a product website earns a visitor’s trust through honest signals, clear information, and substance rather than badges and bold claims.
Mykhailo Boichuk7 min read
From Plain Text to Print: Document Rendering on macOS (the TextPack Case)
How a macOS utility turns plain text into well-formed PDF, covering text layout, pagination, and the rendering pipeline behind print-quality output.
Mykhailo Boichuk7 min read
App Sandboxing and the macOS Security Model
How the macOS sandbox confines apps to protect users, what it permits and restricts, and how to build a capable app within its boundaries.
Maksym Bardakh6 min read
Writing for Both Humans and Language Models
Content is now read by people and by language models. The same qualities that serve readers, clarity and structure, also serve machine understanding.
Mykhailo Boichuk6 min read
Search UX in Small, Focused Apps
How search should behave in a small app, where scope is narrow and the right design is forgiving, fast, and matched to the data.
Maksym Bardakh6 min read
Reducing Decision Fatigue in Scheduling Systems: The Flowo Approach
How scheduling tools cause decision fatigue, and how Flowo reduces it by making fewer decisions and deferring choices to the right moment.
Mykhailo Boichuk6 min read
Accessibility Testing Tools and Workflows
Automated checks catch only part of accessibility. A workflow that combines tooling, keyboard and screen-reader testing, and real users catches the rest.
Maksym Bardakh6 min read
Microcopy and Content Design for Clarity
How the small words in an interface shape understanding, and how to write microcopy that guides the user clearly at the moment they need it.
Mykhailo Boichuk6 min read
Crash Reporting Without Compromising Privacy
How to learn enough from crashes to fix them while collecting no more user data than necessary, keeping diagnostics and privacy compatible.
Mykhailo Boichuk6 min read
A Sustainable Release Cadence for Small Teams
Releasing too often exhausts a small team; too rarely lets risk pile up. A steady, predictable cadence keeps quality high without burning people out.
Maksym Bardakh6 min read
Content Design for AI Answer Extraction
When an AI assistant answers from your content, it extracts a passage. How to write so the passage it lifts is accurate, complete, and attributed to you.
Maksym Bardakh6 min read
Designing Settings: Progressive Disclosure
How to organize settings so common options are easy to find and advanced ones stay available, using progressive disclosure to manage complexity.
Mykhailo Boichuk6 min read
Designing for Interruption and Resumption
People are interrupted mid-task constantly. Preserving state, marking where they left off, and restoring context turn a jarring return into a smooth resumption.
Mykhailo Boichuk6 min read
A Disciplined Product Development Process for a Two-Person Studio
How a two-person software studio ships quality products by replacing heavy process with a few disciplined habits around scope and focus.
Mykhailo Boichuk7 min read
Energy-Efficient UI Rendering on Apple Platforms
How rendering choices affect battery life on Apple platforms, and the patterns that keep an interface smooth without draining the device.
Maksym Bardakh6 min read
Single-Tasking Interfaces: Designing for Focus
Interfaces that present everything at once invite divided attention. Designing for single-tasking means showing one thing to do and protecting it from the rest.
Mykhailo Boichuk6 min read
Rate Limiting and Abuse Prevention Basics
Open endpoints get abused. Rate limiting, sensible defaults, and layered checks protect a service without punishing legitimate users.
Maksym Bardakh6 min read
Telemetry Consent UX Done Right
How to ask for telemetry consent in a way that is honest and clear, so the user’s choice is genuinely informed rather than coerced.
Maksym Bardakh6 min read
Deciding Whether a Feature Earned Its Place
Shipping a feature is not the end of the decision. How to assess, after release, whether a feature earned its keep or should be removed.
Maksym Bardakh6 min read
Progressive Onboarding for Complex Tools
Powerful tools overwhelm if they reveal everything at once. Progressive onboarding teaches capability in layers, as the user is ready for each one.
Maksym Bardakh6 min read
Pricing Fairness and Psychology in Independent Software
How customers judge whether software pricing is fair, and why honest, legible pricing builds more durable trust than psychological tactics.
Maksym Bardakh6 min read
Privacy-Preserving Analytics: Measuring Products Without Surveillance
How to learn what you need about product usage without tracking individuals, using aggregation, on-device processing, and strict data minimization.
Mykhailo Boichuk6 min read
The Case for Boring Technology
Choosing well-understood, proven tools over novel ones is an underrated engineering strategy. Why boring technology often delivers more than exciting alternatives.
Mykhailo Boichuk6 min read
Writing Documentation People Actually Read
Why most documentation goes unread, and how to write docs that answer real questions, stay current, and respect the reader’s time.
Maksym Bardakh6 min read
Designing a Changelog People Actually Read
Most changelogs are ignored because they list commits, not changes that matter. How to write one that tells users what changed for them and why.
Mykhailo Boichuk7 min read
Caching Strategies for Responsive Applications
How caching makes applications feel fast, the strategies for keeping cached data fresh, and why invalidation is the hard part.
Maksym Bardakh6 min read
A Privacy-Respecting Product Feedback Loop
You can understand how a product is used without surveilling users. Consent, minimal data, and direct channels build a feedback loop people trust.
Mykhailo Boichuk8 min read
Offline-First Sync: Conflict Resolution Strategies (CRDTs and Beyond)
How offline-first apps reconcile concurrent edits, from last-writer-wins to CRDTs and operational transformation, with the trade-offs of each.
Mykhailo Boichuk7 min read
Handling Data Deletion Requests in Practice
Deletion sounds simple and rarely is. Backups, caches, logs, and third parties all hold copies. A practical approach to honoring deletion requests fully.
Maksym Bardakh6 min read
The Role of Defaults in Ethical Product Design
Most people never change a default, so defaults are decisions made on their behalf. Setting them in the user’s interest is a core ethical responsibility.
Maksym Bardakh6 min read
Animation with Restraint: Motion That Communicates
How to use motion to clarify rather than decorate, so animation guides attention and explains change instead of demanding it.
Maksym Bardakh6 min read
Measuring Readability and Information Scent
Readability is more than reading level, and information scent decides whether people follow a path. How to assess both so content guides rather than stalls.
Maksym Bardakh6 min read
One-Time Pricing Versus Subscriptions for Independent Software
A clear-eyed comparison of one-time purchases and subscriptions for independent software, and how the choice should follow the product's costs.
Maksym Bardakh6 min read
Designing for Memory and Recall, Not Only Attention
Interfaces compete for attention but rarely support memory. Recognition over recall, durable cues, and respecting working-memory limits make tools easier to return to.
Maksym Bardakh7 min read
Designing for Neurodivergent Users Beyond ADHD
How to design software for a range of neurodivergent needs, from autism to dyslexia, by offering flexibility rather than one fixed experience.
Maksym Bardakh6 min read
Internal Linking Strategy for Topical Authority
Internal links tell search engines and readers how a site’s ideas connect. A deliberate structure builds topical authority and helps every page be found.
Mykhailo Boichuk6 min read
Structured Data and Schema.org for Machine-Readable Websites
How structured data with schema.org and JSON-LD makes a website machine-readable, and how to add it correctly without misrepresenting your content.
Mykhailo Boichuk7 min read
Core Data, SQLite, or Flat Files: Choosing Local Storage
How to choose among Core Data, SQLite, and flat files for an app’s local storage, based on the shape of the data and the queries you need.
Maksym Bardakh6 min read
Structured Content Models for AI Retrieval
Language models retrieve and cite content more reliably when it is structured. How to model content so a passage answers a question on its own.
Mykhailo Boichuk7 min read
File Formats and Longevity: Designing for Data Portability
How the choice of file format determines whether a user’s data survives the software, and why portability is an act of respect.
Maksym Bardakh6 min read
Designing Notifications People Keep Enabled
The real measure of a notification system is how many notifications people leave on. Relevance, control, and restraint keep a channel worth attending to.
Maksym Bardakh6 min read
Designing for Cognitive Accessibility
Cognitive accessibility is often overlooked. Plain language, predictable structure, and reduced load make products usable for a far wider range of people.
Mykhailo Boichuk6 min read
Generative Engine Optimization (GEO): Structuring Content for AI Assistants
How to structure and write content so AI assistants can understand, summarize, and represent it accurately when generating answers for users.
Mykhailo Boichuk6 min read
Reducing App Launch Time on Apple Platforms
Launch time is the first impression. How to find what work blocks the first frame and defer or remove it so an app feels instant from the tap.
Maksym Bardakh6 min read
Reminders Without Nagging: The Ethics of Notifications
How to design notifications that genuinely help rather than exploit, respecting the user’s attention as something borrowed, not owned.
Maksym Bardakh6 min read
Designing Trust into Checkout and Payments
Checkout is where doubt is most expensive. Clarity about price, security cues that are real, and recoverable errors decide whether people complete a purchase.
Maksym Bardakh7 min read
Answer Engine Optimization (AEO): How LLMs Select and Cite Sources
How large language models choose which sources to cite in their answers, and how to structure content so it can be retrieved, extracted, and attributed.
Mykhailo Boichuk6 min read
Reducing Bundle Size in Modern Web Apps
JavaScript is the most expensive resource a page ships. Code splitting, tree shaking, and dependency discipline keep bundles small and pages responsive.
Maksym Bardakh6 min read
The Case for Fewer Features: Scope Discipline
Why adding features steadily makes a product worse, and how scope discipline keeps software focused, maintainable, and genuinely useful.
Mykhailo Boichuk7 min read
Writing Migration-Safe Database Schemas
Schema changes can lock tables and break running code. Backward-compatible, multi-step migrations let a schema evolve without downtime or broken deploys.
Maksym Bardakh6 min read
Designing a Minimal, Durable Design System
How a small team can build a design system that stays useful for years by keeping it minimal, grounded in tokens, and built only as real needs appear.
Mykhailo Boichuk7 min read
Keyboard Accessibility and Focus Management
Everything must work from the keyboard. Visible focus, logical order, and disciplined focus management for menus and dialogs make an interface operable by all.
Maksym Bardakh6 min read
Measuring Perceived Performance, Not Just Metrics
Why how fast software feels matters as much as how fast it is, and how to design for perceived performance alongside raw numbers.
Mykhailo Boichuk6 min read
Typography Systems for Product Interfaces
How to build a typographic system for software using a modular scale, sensible line length and spacing, and a small set of consistent roles.
Maksym Bardakh6 min read
Designing Dark Mode Without Doubling the Work
Dark mode is not an inverted light theme. Semantic color tokens and a few principles let one system serve both modes without maintaining two designs.
Maksym Bardakh6 min read
Designing Keyboard Shortcuts That Stick
Shortcuts only help if people remember them. Consistency, mnemonic mappings, and discoverability turn shortcuts from a hidden feature into a learned habit.
Mykhailo Boichuk7 min read
Internationalization and Text-Rendering Pitfalls
The hidden assumptions about language and text that break software in other locales, and how to design for the world from the start.
Mykhailo Boichuk6 min read
Logging and Observability for Small Apps
Observability is not only for large systems. A small app needs enough logging to answer what happened, without drowning in noise or capturing personal data.
Maksym Bardakh6 min read
Accessible by Default: Meeting WCAG Without Sacrificing Aesthetics
How to meet WCAG accessibility standards while keeping a product visually refined, by treating accessibility as a constraint that improves design.
Maksym Bardakh6 min read
Cognitive Load and Interface Density: An Evidence-Based Approach
How interface density affects cognitive load, and how to decide how much to show on screen based on the kind of mental effort a task demands.
Maksym Bardakh6 min read
Onboarding Paths from Empty State to First Value
The empty state is where users decide to stay or leave. How to design the shortest honest path from a blank screen to the product’s first real value.
Mykhailo Boichuk7 min read
Threat Modeling for Small Software Teams
A lightweight, practical approach to threat modeling that a small team can actually use to find and prioritize security risks before they ship.
Mykhailo Boichuk6 min read
Data Export Formats Users Can Trust
Export is a promise that users own their data. The format decides whether that promise is real. What makes an export complete, open, and actually usable.
Mykhailo Boichuk7 min read
SwiftUI State Management at Scale: Patterns and Pitfalls
How to keep SwiftUI state predictable as an app grows, with guidance on ownership, sources of truth, and the most common mistakes.
Mykhailo Boichuk6 min read
Image Optimization for Fast, Private Websites
Images dominate page weight. How to serve the right format and size, defer offscreen images, and reserve space so layout stays stable as they load.
Maksym Bardakh6 min read
Designing Empty States and Error States Well
Why empty and error states deserve as much care as the happy path, and how to turn these moments into guidance instead of dead ends.
Mykhailo Boichuk7 min read
Native macOS Performance: Principles, Measurement, and Budgets
How to keep a native macOS app fast by protecting the main thread, measuring with the right tools, and working to explicit performance budgets.
Mykhailo Boichuk7 min read
Building a Component Library That Scales
A component library succeeds when it reduces decisions, not when it covers every case. Composition, tokens, and clear ownership keep it usable as it grows.
Mykhailo Boichuk6 min read
Keyboard-First Design for Power Users
How to design software that rewards keyboard fluency with shortcuts, command interfaces, and full navigability, without abandoning newcomers.
Maksym Bardakh6 min read
The Ethics of Streaks and Gamification
Streaks and points can support a habit or exploit one. Where motivation design crosses from helping the user into serving engagement at their expense.
Maksym Bardakh6 min read
Color and Contrast Systems for Light Interfaces
How to build a light-mode color system that stays legible and calm, using a small palette, deliberate contrast, and color that carries meaning.
Maksym Bardakh6 min read
Designing for First-Run Versus Returning Users
The same screen serves a confused newcomer and a fluent regular. How to design so first-run guidance does not become permanent clutter for returning users.
Maksym Bardakh7 min read
Data Minimization by Design: Engineering Under PIPEDA and GDPR
How to build products that collect only what they need, treating data minimization as an engineering practice rather than a policy afterthought.
Mykhailo Boichuk7 min read
Designing for Slow and Offline Networks
Connectivity is intermittent, not binary. How to build apps that stay usable on slow links and degrade gracefully when the network disappears entirely.
Mykhailo Boichuk7 min read
Battery-Aware Background Scheduling on iOS
How iOS governs background work to protect battery life, and how to schedule deferred tasks that the system will actually run.
Mykhailo Boichuk6 min read
Secrets Management for Small Teams
API keys, signing certificates, and tokens leak through habit, not malice. Practical secrets hygiene for small teams without enterprise infrastructure.
Maksym Bardakh6 min read
Haptics in Calm Interfaces: When Touch Should Speak
How to use haptic feedback sparingly and meaningfully, so that touch confirms and guides without adding to the noise of an interface.
Maksym Bardakh7 min read
On-Device AI Versus Cloud Inference: A Privacy and Latency Analysis
Comparing on-device and cloud machine-learning inference across privacy, latency, cost, and capability so teams can choose deliberately.
Mykhailo Boichuk6 min read
Designing Undo: Forgiveness as a Feature
Reliable undo lets people act without fear. How to design forgiveness through reversible actions, clear scope, and recovery rather than confirmation dialogs.
Maksym Bardakh6 min read
Writing Error Messages That Help
An error message is a moment of friction that can either rescue or abandon the user. What separates a message that helps from one that blames or confuses.
Mykhailo Boichuk7 min read
Memory-Safe Patterns in Swift
How Swift’s ownership and reference-counting model prevents whole classes of memory bugs, and the patterns that keep retain cycles and leaks away.
Mykhailo Boichuk7 min read
Date, Time, and Timezone Handling Without Bugs
Time is full of traps: offsets, daylight saving, leap seconds, and ambiguous local times. A few disciplines remove most date and timezone bugs.
Mykhailo Boichuk7 min read
Local-First Software: Architecture, Trade-offs, and When to Choose It
A practical look at local-first architecture, where the user's device holds the source of truth, and how to weigh its benefits against its costs.
Maksym Bardakh6 min read
Designing Accessible Forms
Forms are where many users succeed or give up. Labels, error handling, focus order, and clear instructions decide whether a form is usable by everyone.
Maksym Bardakh6 min read
Designing Onboarding That Respects Attention
Why most onboarding overspends a new user’s attention, and how to design a first run that teaches through use rather than upfront instruction.
Mykhailo Boichuk7 min read
Web Performance Budgets and Core Web Vitals in Practice
Performance budgets turn speed from an afterthought into a constraint. How to set them, tie them to Core Web Vitals, and enforce them before regressions ship.
Maksym Bardakh6 min read
Designing for Executive Function: Reducing Task-Initiation Friction
Why starting a task is harder than doing it, and how interface design can lower the activation cost for people with executive-function differences.
Mykhailo Boichuk7 min read
Choosing a Rendering Strategy: SSR, SSG, and Static Export
Server rendering, static generation, and full static export each answer different questions about freshness, scale, and cost. How to choose deliberately.
Mykhailo Boichuk6 min read
Designing a Settings Search That Genuinely Helps
Settings grow faster than navigation can organize them. A good search indexes labels and synonyms, returns the control itself, and tolerates vague queries.
Mykhailo Boichuk6 min read
Scheduling Local Notifications on iOS Correctly
Local notifications seem simple until time zones, limits, and delivery rules intervene. How to schedule them so they fire when and how the user expects.
Mykhailo Boichuk7 min read
Versioning Local Data: Migrations Without Data Loss
How to evolve a local data schema across app versions on devices you do not control, with migrations that never silently discard a user’s data.
Maksym Bardakh6 min read
The Attention Cost of Notifications, Examined
Notifications are not free. They borrow attention, interrupt working memory, and accrue a cost users eventually repay by disabling them entirely.
Maksym Bardakh6 min read
Designing for One-Handed Mobile Use
Reach, thumb zones, and the realities of holding a large phone in one hand, and how to place primary actions where they can actually be reached.
Maksym Bardakh6 min read
A Calm Color System for Long Working Sessions
Color that works for a glance can fatigue over hours. How to build a restrained, low-strain palette that stays comfortable through a long working session.
Mykhailo Boichuk7 min read
Swift Concurrency: Structured Tasks and Actors in Practice
A practical account of structured concurrency, actors, and data isolation in Swift, with the trade-offs and failure modes that show up in real apps.
Mykhailo Boichuk6 min read
Designing Focus Modes That Reduce Overwhelm
How to build focus modes that genuinely narrow attention rather than adding another layer of configuration and noise for the user to manage.