System Design Cheat Sheet

Posted : admin On 1/3/2022
  1. System Analysis And Design Cheat Sheet
  2. System Design Cheat Sheet Template
  3. Cheat Sheet Samples
  4. System Design Cheat Sheet Pdf
  5. Thermal System Design Cheat Sheet

Printable Cheat Sheet. This brand colors cheat sheet is designed to be attached to the bottom of a monitor for quick color reference. Three quick references fit on a single 8.5' x 11' sheet, so you can print extra references for friends! Download Cheat Sheet. Design Yelp, a location-based system 20: Design 21: Design amazon book recommendation system 22: Design Google PageRank 23: Design messaging/notification system 24: Design memcache/redis 25: Design a voice conference system 26: Design an API gateway 27: Design slack 28: Design a service auto-discovery feature 29: Design a secrets. 646: Sewing, clothing, costume design, hair, and makeup. A cosplayer’s best bet. 700s (The Arts) 709: Art history; 720s: Architecture. But actual construction is back in the 600s with technology. See how the system makes order of the universe? I.big glittery heart. Dewey. 741.5: Graphic novels and cartoons. Oh, this is a wondrous number.

Summary: User research can be done at any point in the design cycle. This list of methods and activities can help you decide which to use when.

User-experience research methods are great at producing data and insights, while ongoing activities help get the right things done. Alongside R&D, ongoing UX activities can make everyone’s efforts more effective and valuable. At every stage in the design process, different UX methods can keep product-development efforts on the right track, in agreement with true user needs and not imaginary ones.

One of the questions we get the most is, “When should I do user research on my project?” There are three different answers:

  • Do user research at whatever stage you’re in right now. The earlier the research, the more impact the findings will have on your product, and by definition, the earliest you can do something on your current project (absent a time machine) is today.
  • Do user research at all the stages. As we show below, there’s something useful to learn in every single stage of any reasonable project plan, and each research step will increase the value of your product by more than the cost of the research.
  • Do most user research early in the project (when it’ll have the most impact), but conserve some budget for a smaller amount of supplementary research later in the project. This advice applies in the common case that you can’t get budget for all the research steps that would be useful.

The chart below describes UX methods and activities available in various project stages.

Each project is different, so the stages are not always neatly compartmentalized. The end of one cycle is the beginning of the next.

The important thing is not to execute a giant list of activities in rigid order, but to start somewhere and learn more and more as you go along.

Top UX Research Methods
Discover• Field study
• Diary study
• User interview
• Stakeholder interview
• Requirements & constraints gathering
Explore• Competitive analysis
• Design review
• Persona building
• Task analysis
• Journey mapping
• Prototype feedback & testing (clickable or paper prototypes)
• Write user stories
• Card sorting
Test• Qualitative usability testing (in-person or remote)
• Benchmark testing
• Accessibility evaluation
Listen• Survey
• Analytics review
• Search-log analysis
• Usability-bug review
• Frequently-asked-questions (FAQ) review

When deciding where to start or what to focus on first, use some of these top UX methods. Some methods may be more appropriate than others, depending on time constraints, system maturity, type of product or service, and the current top concerns. It’s a good idea to use different or alternating methods each product cycle because they are aimed at different goals and types of insight. The chart below shows how often UX practitioners reported engaging in these methods in our survey on UX careers.

If you can do only one activity and aim to improve an existing system, do qualitative (think-aloud) usability testing, which is the most effective method to improve usability. If you are unable to test with users, analyze as much user data as you can. Data (obtained, for instance, from call logs, searches, or analytics) is not a great substitute for people, however, because data usually tells you what, but you often need to know why. So use the questions your data brings up to continue to push for usability testing.


The discovery stage is when you try to illuminate what you don’t know and better understand what people need. It’s especially important to do discovery activities before making a new product or feature, so you can find out whether it makes sense to do the project at all.

System Analysis And Design Cheat Sheet

An important goal at this stage is to validate and discard assumptions, and then bring the data and insights to the team. Ideally this research should be done before effort is wasted on building the wrong things or on building things for the wrong people, but it can also be used to get back on track when you’re working with an existing product or service.

Good things to do during discovery:

  • Conduct field studies and interview users: Go where the users are, watch, ask, and listen. Observe people in context interacting with the system or solving the problems you’re trying to provide solutions for.
  • Run diary studies to understand your users’ information needs and behaviors.
  • Interview stakeholders to gather and understand business requirements and constraints.
  • Interview sales, support, and training staff. What are the most frequent problems and questions they hear from users? What are the worst problems people have? What makes people angry?
  • Listen to sales and support calls. What do people ask about? What do they have problems understanding? How do the sales and support staff explain and help? What is the vocabulary mismatch between users and staff?
  • Do competitive testing. Find the strengths and weaknesses in your competitors’ products. Discover what users like best.


Exploration methods are for understanding the problem space and design scope and addressing user needs appropriately.

  • Compare features against competitors.
  • Do design reviews.
  • Use research to build user personas and write user stories.
  • Analyze user tasks to find ways to save people time and effort.
  • Show stakeholders the user journey and where the risky areas are for losing customers along the way. Decide together what an ideal user journey would look like.
  • Explore design possibilities by imagining many different approaches, brainstorming, and testing the best ideas in order to identify best-of-breed design components to retain.
  • Obtain feedback on early-stage task flows by walking through designs with stakeholders and subject-matter experts. Ask for written reactions and questions (silent brainstorming), to avoid groupthink and to enable people who might not speak up in a group to tell you what concerns them.
  • Iterate designs by testing paper prototypes with target users, and then test interactive prototypes by watching people use them. Don’t gather opinions. Instead, note how well designs work to help people complete tasks and avoid errors. Let people show you where the problem areas are, then redesign and test again.
  • Use card sorting to find out how people group your information, to help inform your navigation and information organization scheme.


Testing and validation methods are for checking designs during development and beyond, to make sure systems work well for the people who use them.

  • Do qualitative usability testing. Test early and often with a diverse range of people, alone and in groups. Conduct an accessibility evaluation to ensure universal access.
  • Ask people to self-report their interactions and any interesting incidents while using the system over time, for example with diary studies.
  • Audit training classes and note the topics, questions people ask, and answers given. Test instructions and help systems.
  • Talk with user groups.
  • Staff social-media accounts and talk with users online. Monitor social media for kudos and complaints.
  • Analyze user-forum posts. User forums are sources for important questions to address and answers that solve problems. Bring that learning back to the design and development team.
  • Do benchmark testing: If you’re planning a major redesign or measuring improvement, test to determine time on task, task completion, and error rates of your current system, so you can gauge progress over time.


Listen throughout the research and design cycle to help understand existing problems and to look for new issues. Analyze gathered data and monitor incoming information for patterns and trends.

  • Survey customers and prospective users.
  • Monitor analytics and metrics to discover trends and anomalies and to gauge your progress.
  • Analyze search queries: What do people look for and what do they call it? Search logs are often overlooked, but they contain important information.
  • Make it easy to send in comments, bug reports, and questions. Analyze incoming feedback channels periodically for top usability issues and trouble areas. Look for clues about what people can’t find, their misunderstandings, and any unintended effects.
  • Collect frequently asked questions and try to solve the problems they represent.
  • Run booths at conferences that your customers and users attend so that they can volunteer information and talk with you directly.
  • Give talks and demos: capture questions and concerns.



Ongoing and strategic activities can help you get ahead of problems and make systemic improvements.

  • Find allies. It takes a coordinated effort to achieve design improvement. You’ll need collaborators and champions.
  • Talk with experts. Learn from others’ successes and mistakes. Get advice from people with more experience.
  • Follow ethical guidelines. The UXPA Code of Professional Conduct is a good starting point.
  • Involve stakeholders. Don’t just ask for opinions; get people onboard and contributing, even in small ways. Share your findings, invite them to observe and take notes during research sessions.
  • Hunt for data sources. Be a UX detective. Who has the information you need, and how can you gather it?
  • Determine UX metrics. Find ways to measure how well the system is working for its users.


  • Follow Tog's principles of interaction design.
  • Use evidence-based design guidelines, especially when you can’t conduct your own research. Usability heuristics are high-level principles to follow.
  • Design for universal access. Accessibility can’t be tacked onto the end or tested in during QA. Access is becoming a legal imperative, and expert help is available. Accessibility improvements make systems easier for everyone.
  • Give users control. Provide the controls people need. Choice but not infinite choice.
  • Prevent errors. Whenever an error occurs, consider how it might be eliminated through design change. What may appear to be user errors are often system-design faults. Prevent errors by understanding how they occur and design to lessen their impact.
  • Improve error messages. For remaining errors, don’t just report system state. Say what happened from a user standpoint and explain what to do in terms that are easy for users to understand.
  • Provide helpful defaults. Be prescriptive with the default settings, because many people expect you to make the hard choices for them. Allow users to change the ones they might need or want to change.
  • Check for inconsistencies. Work-alike is important for learnability. People tend to interpret differences as meaningful, so make use of that in your design intentionally rather than introducing arbitrary differences. Adhere to the principle of least astonishment. Meet expectations instead.
  • Map features to needs. User research can be tied to features to show where requirements come from. Such a mapping can help preserve design rationale for the next round or the next team.
  • When designing software, ensure that installation and updating is easy. Make installation quick and unobtrusive. Allow people to control updating if they want to.
  • When designing devices, plan for repair and recycling. Sustainability and reuse are more important than ever. Design for conservation.
  • Avoid waste. Reduce and eliminate nonessential packaging and disposable parts. Avoid wasting people’s time, also. Streamline.
  • Consider system usability in different cultural contexts. You are not your user. Plan how to ensure that your systems work for people in other countries. Translation is only part of the challenge.
  • Look for perverse incentives. Perverse incentives lead to negative unintended consequences. How can people game the system or exploit it? How might you be able to address that? Consider how a malicious user might use the system in unintended ways or to harm others.
  • Consider social implications. How will the system be used in groups of people, by groups of people, or against groups of people? Which problems could emerge from that group activity?
Cheat sheet samples


  • Protect personal information. Personal information is like money. You can spend it unwisely only once. Many want to rob the bank. Plan how to keep personal information secure over time. Avoid collecting information that isn’t required, and destroy older data routinely.
  • Keep data safe. Limit access to both research data and the data entrusted to the company by customers. Advocate for encryption of data at rest and secure transport. A data breach is a terrible user experience.
  • Deliver both good and bad news. It’s human nature to be reluctant to tell people what they don’t want to hear, but it’s essential that UX raise the tough issues. The future of the product, or even the company, may depend on decisionmakers knowing what you know or suspect.
  • Track usability over time. Use indicators such as number and types of support issues, error rates and task completion in usability testing, and customer satisfaction ratings, to show the effectiveness of design improvements.
  • Include diverse users. People can be very different culturally and physically. They also have a range of abilities and language skills. Personas are not enough to prevent serious problems, so be sure your testing includes as wide a variety of people as you can.
  • Track usability bugs. If usability bugs don’t have a place in the bug database, start your own database to track important issues.


  • Pay attention to user sentiment. Social media is a great place for monitoring user problems, successes, frustrations, and word-of-mouth advertising. When competitors emerge, social media posts may be the first indication.
  • Reduce the need for training. Training is often a workaround for difficult user interfaces, and it’s expensive. Use training and help topics to look for areas ripe for design changes.
  • Communicate future directions. Customers and users depend on what they are able to do and what they know how to do with the products and services they use. Change can be good, even when disruptive, but surprise changes are often poorly received because they can break things that people are already doing. Whenever possible, ask, tell, test with, and listen to the customers and users you have. Consult with them rather than just announcing changes. Discuss major changes early, so what you hear can help you do a better job, and what they hear can help them prepare for the changes needed.
  • Recruit people for future research and testing. Actively encourage people to join your pool of volunteer testers. Offer incentives for participation and make signing up easy to do via your website, your newsletter, and other points of contact.


Use this cheat-sheet to choose appropriate UX methods and activities for your projects and to get the most out of those efforts. It’s not necessary to do everything on every project, but it’s often helpful to use a mix of methods and tend to some ongoing needs during each iteration.

Related article: When to Use Which User-Experience Research Methods


  • PDF Link: cheatsheet-systemdesign-A4.pdf, Category: interview
  • Blog URL:
  • Related posts: CheatSheet: Leetcode For Code Interview, CheatSheet: Well-Known Papers For IT Industry, #denny-cheatsheets

File me Issues or star this repo.

1.1 Reference

YouTubeYouTube: Intro to Architecture and Systems Design Interviews, YouTube: System Design Interview
YouTubeYouTube Channel: Success in Tech, YouTube: Scalability Harvard Web Development
YouTubeYouTube: Prepare for Your Google Interview: Systems Design
PapersCheatSheet: Well-Known Papers For IT Industry, Github: papers-we-love
GithubGithub: donnemartin/system-design-primer, Github: checkcheckzz/system-design-interview
GithubGithub: puncsky/system-design-and-architecture, Github: yangshun/tech-interview-handbook
WebsiteWebsite: hiredintech – System Design, Website:
WebsiteWebsite:, Website:
CheatsheetCheatSheet: Leetcode For Code Interview, CheatSheet: Common Code Problems & Follow-ups
CheatsheetCheatSheet: System Design For Job Interview, CheatSheet: SRE/DevOps/Sysadmin
CheatsheetCheatSheet: Behavior Questions For Coder Interview, Programming Language Implemenetations CheatSheet
CheatsheetCheatSheet: Concurrency & Parallel Programming
CodingCode problems for #oodesign
Individual Tech BlogBlog: highscalability, Blog: All Things Distributed – Amazon CTO
Company Tech BlogWebsite: Facebook Engineering, Website: Google Developers
Company Tech BlogMedium: Netflix Blog, Medium: Airbnb Engineering & Data Science
Company Tech BlogMedium: Instagram Engineering, Medium: Mixpanel
Company Tech BlogShopify Engineering, Github Engineering
Company Tech BlogDoordash Engineering, Uber Engineering
ReferenceLink: Facebook Engineering Interview, Link: The System Design Process

1.2 Design Problems Per Category

1K/V DB storeDesign K/V DB; Design memcache/redis
2Data synchronizationDesign dropbox client sync
3Resource/Task schedulingDesign web crawler; Delayed task queue; Design a distributed message queue
4Design a distributed componentDesign a distributed hit counter, Design a distributed UUID generator
5Design a SNS systemDesign Twitter News Feed
6Design API GatewayDesign An API Rate Limiter
7Design a logging & metrics systemPull vs Push model
8Design a gaming systemDesign: Leaderboard Ranking
10Design a small scale MIS systemDesign: Flight booking service, Design a payment processor
11Recommendation systemDesign amazon book recommendation system
12Design a communication systemDesign a message chat room
13Design an ads system

1.3 Top 50 Component Design

1Top K Frequent Elements in Recent X minsGithub: link
2Design An API Rate Limiter
3Design: Leaderboard Ranking
4Delayed task queue
5Spam Filter: design a system to block malicious IPsGithub: link
6Find duplicates files across 1000 servers with 10 million filesGithub: link
7Design a monitoring system to check 10,000 nodesGithub: link
8Design a scalable and reliable notification serviceGithub: link
9Web crawler for 1 billion URL from 1 seed URLGithub: link
10Design twitter timeline featureGithub: link
11How to upload large videos at scaleGithub: link
12Real-time Deduping At ScaleGithub: link
13How quoram based DB works when nodes join or leave
14How to implement redis clusteringGithub: link
15How to deployment 1GB binary to 10,000 serversGithub: link
16How to distribute TB data from a server to 10,000 nodes
17Merge big datasets across different serversGithub: link
18Unique url hits
19Design a distributed counter
20Design a distributed message queue
21Design a distributed cache service
22Design a distributed Hashmap
23Design a distributed UUID generator
24Design a git service
25Design: A Parking Lot Service
26Design a distributed transaction
27Design: A URL Redirecting Feature
28Give three 1TB disks, how to store 2TB data with redundancyGithub: link. XOR bit manipulation
29How to support feature of “diff big1.bin big2.bin”#lcs – Longest Common Subsequence
30How to support “rsync big1.bin ssh:/big2.bin” in a doggy networkdelta-transfer algorithm. Weak Hashing + Strong Hashing
31Avoid double payment in a distributed payment systemLink: Avoiding Double Payments in a Distributed Payments System

1.4 Concurrency Problems

1.5 Top 30 Product Design

1Design: TinyURL – A URL Shorterner Service
2Design Twitter News Feed
3Design K/V DB
4Design autocomplete/typeahead
5Design a online contest system like
6Design Google Calendar
7Design a load balancer
8Design: Flight booking service
9Design: Uber Backend
10Design: An Elevator Service
11Design amazon shopping cart
12Design: Google Suggestion Service
13Design a payment processor
14Design google doc
15Design gmail
16Design RSS news reader
17Design a client-server API to build a rich document editor
18Design instagram, a photo sharing app
19Design Yelp, a location-based system
21Design amazon book recommendation system
22Design Google PageRank
23Design messaging/notification system
24Design memcache/redis
25Design a voice conference system
26Design an API gateway
27Design slack
28Design a service auto-discovery feature
29Design a secrets management system
30Design Google Adsense fraud detection
31Design The Great Firewall

1.6 Process Of System Design

1Outline use cases: List major and focus on someShow good sense. The questions you asked define your level
2Estimate scale: Data + TrafficBack-of-the-envelope estimation
3Defining data modelIt helps to clarify how data will flow among different components
4Abstract designSketch main components, explain workflow, avoid too deep for details
5Detailed design + discussion with interviewersExplain trade-off of your proposal + on-demand deep dive
6Identify and resolve BottlenecksKey challenges + Trade-Offs. Usuaully no optimal solution(s)
7Scale your designAvailability, Resiliency, Scalability, Security, Serviceability, etc
8Show your relevant experience and learningIndustry best practice; You experience of scaling/trade-off/resiliency

1.7 Common Mistakes Of System Design

1Run into an opinioned solutions before clarificationInexperienced; Hard to communicate
2Not driving the conversationInexperienced
3General answers without your personal experience/thinking
4Makes interviewers feeling you’re stubborn

1.8 Top 30 Concepts For Feature/System Design

1CachingStores data so that future requests of data retrieval can be faster
2Message QueueProvides an asynchronous communications protocol,
3Data Partition & ShardingBreak up a big data volume into many smaller parts
4DB IndexingCreate indexes on multiple columns to speed up table look up
5DB replicationDuplicate data to increase service availability
6CAP: Consistency/Availability/PartitionA distributed database system can only have 2 of the 3
7DB: SQL & NoSQLRelational databases and non-relational databases
8Concurrency & Communication
9Pessimistic And Optimistic Locking
10Consistency Moduleweak consistency, eventual consistency, strong consistency
11Conflict resolutionQuorum, vector lock, reconcile on read/write, CRDTs
12B+ Tree
13Networking: HTTP
14Networking: TCP/UDP
15Pull vs Push model
16Garbage Collection
17Memory Management
19Self ProtectionAPI Rate limit, Circuit breaker, bulkhead, throttling
21API: RPC vs gRPC vs REST
22Load balancer
23Scale up vs Scale outVertical scaling and Horizontal scaling
24API Design
25Session management
26Networking: TCP vs UDP
27Consistency patternsWeak consistency, Eventual consistency, Strong consistency
28Availability patternsFail-over vs Replication
29CDN – Content Delivery NetworkEdge caching
32Networking: DNS
33Linux signals

1.9 Top 20 Advanced Data Structure & Algorithms

System Design Cheat Sheet Template

1Consistent Hash
2Bloom filterA space-effcient query returns either “possibly in set” or “definitely not”
3hyerloglog for count-distinct problemEstimation: the count of unique values with relatively high accuracy(98%)
4Reservoir Sampling
5Merkle Tree
6LPM(Longest Prefix Match)
7Frugal Streaming
8GossipPropagate cluster status
9Vector Clocks/Version Vectors
10Lossy Counting
11Skip list
12CRDTs (Conflict-Free Replicated Data Types)
13choice-of-2 in load balancer
14Range-based query
15SSTable (Sorted Strings Table)
17LSM (Log Structured Merge Trees)
18Two-phase commit/Three-phase commitGithub: link
19Paxos and raft protocol
20Ring buffer
21cuckoo hashingResolve hash collisions with worst-case constant lookup time
22snappy/lzssFast data compression and decompression
23S2 GeometryBuild geographic database in a better way
26DHT – distributed hash table

1.10 Explain tools: how XXX supports XXX?

1How JDK implement hashmap?
2Explain java garbage collection model
3Explain raft/etcd
4How OS supports XXX?

1.11 Cloud Design Principles

1Fail fast
2Design for failure
3Immutable infrastructure
4Cats vs CattleAvoid snowflake servers
5Auto healing
6Async programming
7GitOps operational model
8Event-Driven Architectures

1.12 Cloud Design Patterns

1Ambassador patternCreate helper service to send network requests, besides the main sevice
2Cache-Aside patternLoad data on demand into a cache from a data store
3Circuit Breaker patternIf a request takes too many reousrce, abort it
4Bulkhead patternIsolate elements into pools, so that one fire won’t burn all
5Gateway Aggregation patternAggregate multiple individual requests into a single request
6Priority Queue patternSupport different SLAs for different individual clients
7Strangler patternIncrementally migrate a legacy system piece by piece
Thermal system design cheat sheet

Cheat Sheet Samples

1.13 Engineering Of Well-Known Products

GoogleLink: Google Architecture
FacebookLink: Facebook Live Streams
TwitterLink: Twitter Image Service, YouTube: Timelines at Scale
UberLink: Lessons Learned From Scaling Uber
TumblrLink: Tumblr Architecture
StackOverflowLink: Stack Overflow Architecture

System Design Cheat Sheet Pdf

1.14 Grow Design Expertise In Daily Work

1Keep the curiosityThinking about interesting/weird questions helps
2Deep dive into your daily workUnify and normalize problems from daily work
3Learn the work of your coleaguesIndirect working experience also help
4Popular products under the hoodOnce you notice an interesting feature, think about how it’s supported?
5Read engineering blogsEspecially for big companies
6Tools under the hoodCommon tools/frameworks
7Try toolsUse cases; Alternatives; Pros and Cons
8Read papersBest practices in papers
9Try new thingsGain hands-on experience; evaluate alternatives
10Datastore & OSLearn how databases and operating systems work
11Language implementationDeep dive into one programming language. Java, Python, Golang, etc

1.15 More Resources

Thermal System Design Cheat Sheet

License: Code is licensed under MIT License.