Software Development
(WiP)
Web
Backend
Programming Languages
Scripting languages
JavaScript
Node.js
Asynchronous event-driven JavaScript runtime
npm
Node Package Manager
Tools
Prettier (Formatter)
ESLint (Linter)
Python
Libraries
High Performance Languagues
Go
Rust
Functional Languagues
OCaml
Elixir / Haskell / Scala / Clojure
Java / Kotlin / PHP / C# (.NET) / Ruby / F# / R
Frontend
DevOps
Tools
Source Control
Desktop
Terminal
Scripting
Mobile
iOS
Android
Cross-Platform
Flutter / Xamarin / Ionic / Appcelerator
Libraries
Data
Message Brokers
Caching
Analytics / Search
Relational DB
PostgreSQL
Microsoft SQL Server
Redis
Cassandra
NoSQL
MongoDB
Couchbase / RethinkDB
ZeroMQ
Kafka
RabbitMQ
Concepts
Security
OWASP Top Ten (2021)
API Design
- Application Programming Interface
- What is an API?
Legend:
- 📘: Proficient Knowledge
- 🐙: Usable Knowledge
- 📗: Learning In Progress
- 📙: Would like to learn
- 🔴: Not working on
- ❔: Mind map in Progress
Environment
SQLAlchemy (Database)
Tools
flake8 (Linter)
Marshmallow (Data formatting)
Alembic (Database migration)
Architecture
API Patterns
Error Handling
Handling a failing request by sending the appropriate status code and error message.
E.g: HTTP 400 { "error": "B01", "message": "The request parameters are invalid" }
Deployment & Services
Container
Concepts
Delivery
CI/CD Pipelines
(self-hosted) Jenkis
TeamCity / GitLab CI / Codeship / DroneCI / Bamboo / Buddy / GoCD / ...
Dockerfile
Configuration file to build a new image
Basics
WORK IN PROGRESS
Document - <!DOCTYPE html>, <html>, <head>, <body>
Basic Elements - <div>, <a>, <p>, <img>, <h1>, <h2>, <table>, etc.
Element Attributes - id, class, style, etc.
- Meta - <title>, <base>, <meta>
- CSS - <style>, <link rel="stylesheet">
- JavaScript - <script>
Basic Syntax - selector { property: value; }
Forms - <form>, <input>, <select>, <textarea>, etc.
- Basic - element, .class, #id
- Nested - .class .other-class, .class > .child
- Box - display, margin, padding, height/width, border
- Text - color, font-family, font-size, font-weight, text-align, text-decoration, text-transform
- Layout - float, position, flex, grid
Programming Languages
JavaScript
Frameworks
Angular
Tools
create-react-app (app bootstrap)
Apollo (GraphQL)
React Router (Navigation)
Concepts
Tools
Jest / Mocha - Chai / Testing Library (Testing)
Prettier (Formatter)
ESLint (Linter)
TypeScript (Type enabled JS superset)
Storybook (Documentation, Playground)
Puppeteer / Playwright / Cypress / Selenium (E2E Testing, comparison)
TypeScript (Type enabled JS superset)
Stateless Components
JSX
Props Flow
Virtual DOM (applying changes to DOM only when needed)
Rx.js, Immutable.js, Ramda (Functional Programming)
CSS
Frameworks
Native - Using flexbox or grid
Bulma / Tailwind / Skeleton
BEM
SMACSS
Atomic
Precompilers
Dart / PureScript / ClojureScript / Haxe / Nim
- Query Elements - document - getElementById, querySelector
- Modify Elements - element - innerHTML, innerText, attribute, style
- Update Elements - document - createElement, remove/append/replaceChild
- Element Events - element - onclick, onfocus, onload, etc.
Advanced concepts
- Providing enhanced capabilities for website to act more like native apps (geolocation, notification, device info, etc.)
- What can PWA do today?
Storage - Persisting data across navigation and page reload (session, local, cookies, indexDB)
Concepts
User Experience
Accessibility
Designing for a diverse set of users (font size, contrast, dictation software, etc.)
Responsive Design
Designing for a diverse set of devices (laptop, phone, tablet, etc.)
Performance
Offering a smooth user experience within the app (navigation, sync/async interactions, caching, etc.)
Consistency
Maintaining a consistent style guide for the whole app/platform
Internationalization
Allowing an user to navigate the app/platform in the language they feel the most comfortable with
Security
Input validation
Making sure the data sent to the backend has been pre-screened for errors and security concerns
Preventing Cross-Site Scripting
Through unsanitized input, an user can potentially run code on another user's machine
Error handling
Providing meaningful messages to the user and clear recovery steps when something goes wrong on the app or on the Backend
SEO (Search Engine Optimization)
- A process of improving positions in organic (non-paid) search results in search engines
- Learn SEO
Web Sockets (Native, socket.io)
Service Workers - Running JS in the background without affecting the page's performance
Language Basics
- Syntax - Conditions, Comparisons, Variables, Operators, Functions
- Data types - Number, Object, String, Array, Boolean, Date
- Advanced - JSON, Math, RegExp, Class, Promise/Async-Await
- window - screen, location, history, navigator, alert, setTimeout, setInterval etc.
CSS-in-JS
Performance Optimization
- JS/CSS minifying, image optimization, cashing, request and file compression, http2
- FEO Guidelines
Testing / Debugging
- Developer console, E2E testing
- JavaScript Testing and Debugging Tools
yapf (Formatter)
Gunicorn (Server runner)
Pipenv (package/env manager, alternative to pip/venv combo)
Makefile (Building automation tool)
pip (Package Installer) / venv (Virtual Environment)
Frontend can be defined as content and interactions rendered on an Internet Browser based environment.
It ranges from a static web page containing the basics HTML, CSS, JavaScript (early websites), to a server generated content website (blog, news), to a fully featured application containing complex logic and interactions (Netflix, Youtube).
Authentication
Allowing access to resources via valid API keys, OAuth, or JWT (JSON Web Tokens)
SQLite
Backend can be viewed as software running on a server.
It is often associated with the term API, which provide various clients (websites, native apps, automation tools) with a way to interact with assets (data, files) in a secure and logical way.
Developer Tools
IDE
Git
Scalability / Performance
Multi-Threading / Clustering
Optimizing the use of cpus through native multi-threading (C++) or a clustering tool (Node cluster, Python Gunicorn) [Vertical Scaling]
Load Balancing
Using a dedicated tool (Nginx, Kubernetes) to distribute network requests to a series of identical nodes based on the current load capacity of those nodes [Horizontal Scaling]
Database Query Optimization
Identifying long processing or frequently used database queries and implementing solutions such as using database views, read-only clones, improving the query or the database schema
Caching
Saving frequently used assets (data, images) into a fast-access dataset (Redis) to avoid unnecessary calls to Database
Asynchronous processing
Identifying long processing code flow and separating it into another process (worker) that communicates with the main process using message broker (RabbitMQ, Python Celery)
Swift
Uniform interface
Uniquely identify each resource involved in the interaction between the client and the server.
E.g HTTP-method + route: POST /my/route
Layered System
Layers of an API can point to different resources in the system while presenting a unique interface
E.g: /api/topic1 -> server 1; /api/topic2 -> server 2
SOAP
Cron
Having dedicated server(s) running periodic jobs with the goal of maintaining/cleaning/helping a part of the system
Platforms
GitLab / Bitbucket
Offer similar features as GitHub
VSCode / Atom / Sublime Text / etc.
Mercucial / SVN
GitHub
Teams
Organize individual contributors for different access level (e.g admins, developers, testers, etc.)
Repositories
Issues
Notes for improvement suggestion, feature request or general support & discussion
Pull-Requests (PR)
Review code changes before merging them to a another branch
Access-Management
Control Read/Write/Admin access for teams and individual collaborators
Event Hooks
Send notification to a third party systems to monitor or assist GitHub processes (PRs, issues, deployments, etc.)
Branch Protection
Define a set of rules to protect the branches from unwanted or potential hazardous actions (force push, delete, direct push, etc.)
Organizations
Projects
Organize and track issues and PRs in a Kanban/Scrum board
Concepts
Branching
Organize code by features or environments (e.g master, dev, feature/xyz, hotfix/xyz, release/123)
Audit trail
Track what was changed and who made the change at any point in the history of the repository
Team collaboration
Allow for multiple individuals to work on the same project at the same time and allowing for 'easy' merging of various contributions
Branches, Commits, Tags
Merging
Allow for contributions (made in a branch) to be merged into the main system (via a main branch eg. master). Usually requires code conflicts resolution.
Repository
A container for a codebase and its history, branches, commits, etc.
Fork
Duplicating a repo in order to make a contribution back to the main repo or to create a new system based on that initial repo
Concepts
Clone
Pull an entire repo from a remote origin into a local folder
Tagging
Marking a specific commit as a significant point of the history of a repo (e.g versioning: v1.0, v.2.3.4, etc.)
Commits
A single contribution made to a branch that can contain any number of code changes. A series of commits makes up the history of a repo
Push & Pull
Push/apply changes to a remote origin (may require to pull latest changes beforehand)
Pull latest changes from a remote origin (may require conflict resolution)
Hooks
Allow for a process to run upon a git lifecycle event (e.g running a linter before committing a code change)
Repo, Branch, Commit, Tag, Merge
Releases
Using a git tag to describe a release. Usually includes changes description and release notes
HTTP
See: Computer Science > Networking
SourceControl GUI
GitHub Desktop / Tower / etc.
(Native Platform) XCode / Android Studio
Internet Browsers
Chrome / Firefox / Safari
Edge / Opera / Internet Explorer / etc.
Debug / Test
Postman
Chrome DevTools
CLI
Package Manager
Terminal
Language Manager
Container
(Mac) Homebrew
iTerm + zsh
pyenv / nodenv
(Docker) docker / docker-compose
(Linux) apt-get / apk / yum
(Windows) winget
Mac Terminal / Terminator + Sh / Bash / Fish
swift / openjdk / go / opam
(Kubernetes) k3d + k9s + kubectl + helm
Automation
(Request) curl
(Parser) jq / yq
Data
psql
vault
ElasticSearch
Responsibilities
Programming Languages
Swift
Objective-C
Tools
Frameworks
Views / Controls
Concepts
Auto-Layout
CoreData
Architecture
Flow Controllers
3rd Party
Storyboards
Alamofire (Network, alternative to Foundation's URLSession)
View / View Hierarchy
Collection / Table / Stack / Scroll / Image / Text / Label / Web
Button / TextField / Progress Indicator / Pickers / Switchers / Sliders / Page Control / Segmented Control
TestFlight
ViewControllers
Manage Product Page
Manage Releases & Updates
Manage In-App Purchases
Insights & Analytics
Role Access Management
Manage Internal Testers and test builds
Manage External Testers and beta builds
NavigationControllers
Code Editor
Interface Builder
Runner / Debugger
Managing Project Properties
Manage Project workspace & dependencies via cli & Podfile
Install packages from the community & link them to the project
Create packages and distribute them to the community
Realm (Database, alternative to CoreData)
Presenting an Interactive View (Presenter / View Controller)
The goal of a native app is to present an information to an user, via a dedicated container/view, and allow that user to interact with that view in order to perform a specific action.
A view can be anything as simple as a text-box or an input (Button, Text Input), a view containing other views or a complex interactive component such as a map.
Collecting User Inputs
The app should be able to present an interactive view and react to the user inputs on that view.
For example, when presenting a button, the app should known that the button was tapped and perform an action based on the purpose of that button.
On a more complex component like a map, the app should be able to react to all the different inputs from the user (zoom, move around, tap on a spot, recenter on current position, etc.)
Synchronising with the Backend (Network Controller)
On user input, an app can be asked to perform an action that impacts the remote data connected to that app (e.g get a list of article, create a new article).
On such action, the app should be able to make a request to a remote database (via a Backend) and collect the data from a successful call, or the error from a failed call.
Storing Data Locally (Model)
Upon a successful Backend request or during an user input, the app may need to store some information for a later use.
This is usually done via the use of a local database (e.g SQLIte) and used in code via a Model type object
Coordinating the Presented Data (Coordinator / Interactor)
When presenting information to the user via a view, the app may need to collect, curate and/or transform the data before it it presented.
This usually involves gathering data from the local storage, the Backend or a mix of both and curating/transforming that data based on the view's needs.
Coordinating the Flow of Views (Router / Flow Controller)
Defining the interactions between different views to create a user journey.
To achieve this in iOS for example, one could use a Storyboard or a custom NavigationController
E.g (Sign in flow): Welcome View > Sign Up View > Onboarding View > App Main View
Concepts
Fastlane (Deployment CLI)
Updating the View based on changes (State)
After presenting the view, the app should be able to update that view or parts of it based on external changes.
For example: User sees a list of articles > User taps Refresh button > Request to Backend > Request is successful
- In this example, the initial state is a list of articles, as well as a 'none' loading status
- When the request starts, the loading status changes to 'loading', so the view updates to display a loading indicator
- When the request succeeds, the loading status would change to 'none', the loading indicator is hidden, and the list of articles is replaced by the list received by the Backend
Error Recovery
Push Notification
In iOS there exist many types Architecture, but they all try to do the same thing, to give you a way to organise the app Responsibilities (see Native > Responsibilities) in a way that makes sense for a given project.
They all have pros & cons, the most important thing is that once one of them is chosen, use the principles consistently throughout the project.
Analytics
Model
Data as an object. Contains the business logic related to that entity
View
Container for the information presented to the user (e.g UILabel, UIView)
Controller
Handles everything else listed in the Responsibilities (e.g UIViewController, UINavigationController)
Model
(same as for MVC)
View
Manages the views and the user inputs (e.g UIViewController)
View-Model
Object attached to a View, which has the responsibilities of coordinating the data to be presented to the view.
Optionally it can also coordinate requests to the Backend for that view
Flow Controllers
Dedicated object that coordinates interactions between Views that belong to the same flow
E.g, SignInFlow: Welcome View > Sign Up View > Onboading View
MVC / MVVM
Each View can choose to implement the MVC or MVVM patterns based on the complexity of that View
Network Requests
Appearances
JavaScriptCore
swift-format lint / SwiftLint (Linter)
swift-format / SwiftFormat (Formatter)
Micro-Services
Identifying large and/or complex parts of the application that could be extracted into another server, a series of micro-servers, or individual lambda functions in order to scale and maintain independently
KingFisher / Nuke (Image caching/processing)
ReactiveCocoa / RxSwift (Reactive Programming)
Queue / Operations
Primitive Types (String, Array, Dictionary, etc.)
File System
User Defaults
CryptoKit / ARKit / CloudKit / HealthKit / HomeKit
GCD (Concurrency Dispatch)
XCTest
Core ML / Core Audio / Core Graphics / Core Image / Core Location / Core Media / Core Motion / Core Video
File Structure
Micro-Services
SPA
Component-Based Architecture
State
Sync with Backend
Router
Reliability
Continuous Integration (CI)
Linking automated actions to a code repository's commits/merges
Performing tests and code quality (linter, static analyser) controls in a sandbox environment
Making sure the code passes a series of test before being merged to a repository's main branch
Continuous Delivery (CD)
Using CI jobs to make sure the code is deployment ready
Building/Packaging the code into a library (npm, pip) or image (docker)
Publishing the package/image into a remote repository (npm, pypi, docker hub)
Deploying the code/image into a dev/staging/production environment
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications
Cloud Platforms
Small-Medium
DigitalOcean / Vultr / UpCloud / Back4App / ...
Medium-Big
Specialised Services
Shopify (e-commerce)
Firebase (realtime db & analytics)
Tools
helm (cli & charts to package a kubernetes app)
Dokku (self-hosted mini-Heroku)
PubNub (realtime communication & notifications)
docker-compose
CLI & config file to run all the services for a given app (backend, worker, frontend) alongside all its dependencies (postgres, redis, etc.)
Docker CLI
Perform docker actions from the terminal
E.g: docker pull/ push / build / run
Containers offer a logical packaging mechanism in which applications can be abstracted from the environment in which they actually run
kubectl (kubernetes cli)
Service discovery (ingress) and load balancing
Automated rollouts and rollbacks (update deployments, kubectl rollout)
Automatic bin packing (make the best use out of available resources)
Self-healing - restarts/replace/kill containers that fail (Deployment + ReplicaSet)
Secret and configuration management (Secrets, ConfigMaps)
Storage orchestration (Volumes, PV, PVC)
Desktop Apps
Testing
Pen-Tests
Running a series of specific tests designed to find security vulnerabilities in a deployed system. Ideally run before any release that adds a new public ressource (e.g API route)
End-2-End
Running a series of tests over the entire system to make sure that user flows are working properly.
Ideally those are run before a release, as well as periodically (CI job) on a deployed environment (dev, stg, qa)
Unit / Integration
Running a series of tests over the whole codebase, before code merge and releases, to control code quality and prevent bugs.
Usually ran as part of the CI flow
Testing Environments
Setting up environments where tests can be performed without affecting Production data & availability
- Development: Dev team internal testing
- Staging: Production clone with anonymized data
- QA: Optional extra env for a dedicated QA team to perform tests
...
Command Line
E.g: $ rm -f foo.txt
Structure: [prompt] [command] [option] [argument]
File System
(file/folder listing) ls / tree / find
(file display) cat / head / tail / less / more
(physical location) pwd / cd
(folder manipulation) mkdir / rmdir / rm -R
(file manipulation) cp / mv / touch / rm
(result manipulation) grep / sort / uniq / sed
Profile (.bashrc, .zshrc)
(file editor) vi(m) / nano / emacs
alias
PATH
Custom Functions
(list env variables) env
(create new variable) export A_VAR=123
(use variable in command) echo $A_VAR
Important Variables
(create variable only for one command line) DEBUG=1 a_cmd
(env variable that defines where the commands are found) PATH
(where the home directory is located) HOME
(where the current terminal is located) PWD
(current user) USER
(running a command as the root/admin user) sudo
(process manipulation) ps / top / kill
(file permissions) ls -l / chmod / chown
- Terminal > Other Concepts
- Scripting
- Desktop app
(manual/documentation of local commands) man
Laying out the main aspects of Software Development, their important concepts, tools and useful links.
It is meant as a list of organised indexes towards different parts of the Software Development knowledge.
It represents the things I know and where I would like to improve
Related MM:
(stdin) Collecting user input
(stdout) Commands log
(stderr) Commands error log
(Wildcards / Tilde / Dot / Redirection / Pipe)
Java Swing
Unit / UI Testing
Container orchestration (Pod, StatefulSet, Jobs, CronJobs)
Role Based Access Control (Role, RoleBinding)
Injection
Untrusted data is sent to an interpreter as part of a command or query, leading to the execution of unintended commands or unauthorized access
Remediation: Parameterized queries or prepared statements, input validation, and proper encoding
Identification and Authentication Failures
Unauthorized individuals are allowed to compromise user accounts, passwords, or session tokens
Cryptographic Failures
Broken Access Control
Security Misconfiguration
Vulnerable and Outdated Components
Stateless
Each request contains all the necessary information to process the request.
The data layer (db, cache) is separated from the logic layer.
Reliability
Monitoring
Error Logging
Using the Common Logging system to print out detailed messages about an error that occurred in the system to allow for debug or diagnostic of a potential issue.
Common Logging
Following an app lifecycle by printing messages that give out essential information on what happened, when, who was involved.
Preferably JSON based (e.g pino) & levelled (info warn, error)
Performance/Resource Tracking
Proving metrics to an external tool (e.g NewRelic) to learn about a system's capabilities & performance
Fault tolerance
Prevent interruption of service by implementing server restarting mechanisms (e.g load balancing, replica set, clustering)
Error Handling
Forwarding errors upward to the system level to ensure logging complete error data and preventing server from crashing
Database Design
Telemetry / Tracing
Following a request data (logs, metrics, traces) throughout multiple connected services (e.g api - third party - database)
Client-Server
Separation between the client (webpage, app) and the server. So they can be replaced and developed independently, as long as the interface between them is compatible
Cacheable
A client can reuse the data based on the request cache labels set by the server
Authorization
Allowing access to ressources via rules based on user roles, permissions, or scopes
Versioning & Documentation
Providing a thorough document describing the API versioning mechanism, resources (routes), expected input & output and potential errors codes & meaning
Rate Limiting & Throttling
Ensure fair usage and prevent abuse of API ressources by controlling the number of requests allowed within a specific timeframe
Data Modeling
Defining the structure, relationships, and constraints of the data entities within the system
Database Management System (DBMS)
Selecting the appropriate database technology for the system requirements
E.g: Relational (PostgreSQL, MySQL), NoSQL (MongoDB, Cassandra)
Optimizations
Normalization
Decomposing a table into multiple smaller tables and defining relationships between them, to minimize data duplication and improve data integrity
Happens in steps known ad Normal Forms: 1NF, 2NF, 3NF, BCNF, 4NF, 5NF
Indexing
Improve the performance of database queries by creating data structures (indexes) that allow for quick data retrieval.
It involves choosing the appropriate columns to index, adjust them over time and potentially reindexing periodically to continuously improve performances
Query Optimizations
Understanding query execution plans, analyzing query performance, and employing techniques such as indexing, query rewriting, caching, and denormalization to enhance query efficiency
Database Security
Implementing authentication/authorization mechanisms, encrypting data at rest/in-transit and following security best practices to prevent unauthorized data access
Migration & Versioning
Managing changes to the database structure over time, while data consistency and minimal downtime
Data Governance and Compliance
Adhering to data governance principles and complying with legal and regulatory requirements (e.g GDPR, HIPAA)
Data Backup and Recovery
Ensuring data durability and availability by implementing regular data backup and designing disaster recovery plans
Transactions and Concurrency Control
Ensuring integrity and consistency of data by grouping multiple database operations into a single logical unit, managing isolation levels and concurrency
MySQL
Serverless
Monolith
The entire system is built as a single, self-contained application
Pros: Simplicity, easy development and testing and direct access to all components
Cons: Lack of scalability, difficulty in maintaining and deploying updates, potential for a single point of failure
Recommendation: Ideal use for MVPs and small projects, as the system expends, other types of Architecture should be considered
Decomposes the system into smaller, loosely coupled services that communicate with each other via APIs calls
Pros: Scalability, independent development and deployment of services, fault isolation, and technology flexibility for each service
Cons: Increased complexity due to distributed nature, additional overhead in managing inter-service communication, potential performance issues with remote calls
Recommendation: Ideal use for medium to big systems. Drawbacks need to be addressed as the system scales. Using a combination of micro, serverless and event-driven architecture is a good way to address various scale issues
Focus on writing code without managing infrastructure. Backend logic is implemented as functions (e.g AWS Lambda) that are triggered by events
Pros: Scalability and elasticity, reduced operational overhead, pay-per-use pricing model, rapid development and deployment
Cons: Limited control over infrastructure, potential vendor lock-in, performance impacts due to cold starts (initial function invocation latency)
Recommendation: Ideal for a team with little DevOps experience or for running specific async jobs that don't need to live in the main Backend system
Event-Driven
Handles processes based on events and asynchronous messaging. Events trigger actions and allow communication between components
Pros: Loose coupling, scalability, responsiveness to real-time events, flexibility in adding or modifying components
Cons: Complexity in managing event flows, potential issues with event ordering and consistency, debugging and testing challenges
Recommendation: Can be used to aid micro-services to scale and handle async tasks. The complexity of the even flows need to often be monitored and reviewed
Event Sourcing and CQRS
File Structures
Monolithic
All the code and resources of the system reside within a single project or directory. Often used in simpler applications or early MVPs
Layered
Separates the code and ressources by layer following architecture pattern:
Presentation layer - Business logic layer - Data layer
Similar to, but not exactly same as, MVC (Model View Controller) structure
Component Based
Each component/module has its own directory, containing all the necessary code and resources related to that component
Feature Based
Each feature has its own directory, containing all the related code and resources
Modular (packages)
Packages represent logical divisions of code within the system, often aligned with features or functional grouping. They can be worked on and tested individually, as well as reused throughout the project (e.g CLI, API, tests)
These file structures can be used together and complement each other, as long as consistency and understandability is maintained throughout the project
Event sourcing captures and stores all changes to the application state as a sequence of events. CQRS separates the read and write models for improved scalability and flexibility
Pros: Auditability, traceability, scalability, real-time analytics, ability to rebuild state from events
Cons: Increased complexity, additional infrastructure requirements, potential challenges in maintaining consistency across read and write models
Authentication
OAuth 2
A standard designed to allow an application to access resources hosted by other web apps on behalf of a user, so they don't need to share their credentials. OAuth 2 uses an Access Token to access resources on behalf of the end-user
OIDC
An identity protocol that utilizes the authorization and authentication mechanisms of OAuth 2.0. It is often used to identify users and provide SSO capabilities
SAML
An open standard created to provide cross-domain single sign-on (SSO). It allows a user to authenticate in a system and gain access to another system by providing proof of their authentication
gRPC
AI Assistant
Code Organization
Monolith
Multi-Repos
Monorepo
Managed Multi-Repos (gita, mani)
Insecure Design
Software and Data Integrity Failures
Security Logging and Monitoring Failures
Server-Side Request Forgery
Cross Browser/Platform Compatibility
Ensuring compatibility across different browsers (e.g. Chrome, Firefox, Safari) and platforms (e.g., Windows, macOS, mobile devices)
Automated Testing
Writing testable components. Performing unit, integration tests on the codebase. Performing end-2-end tests on the system
Styled Components
EC2 / ECS / EKS (Deployment)
S3 (Storage)
CloudFront (CDN)
SQS (Queue)
SNS (Notifications)
Lambda (Serverless functions)
RDS / Aurora / DynamoDB (Database)
IaC
Infrastructure as Code
Terraform
Ansible
Chef / Puppet / Cloud specific (e.g AWS CloudFormation)
Release/Rollback Strategies
onDelete / Recreate
Remove old version then deploy new one
rollingUpdate / Ramped
Gradually deploy new replicas while removing the old ones
Blue/green
Deploy new version together with old one, then switch when ready
Canary
New version for some users then full rollout when ready
Client Side Authentication
Taking the user through an authentication flow before showing the app's data. Interacting with APIs via authentication tokens (e.g JWT)
HTTPS
Serving the website over HTTPS to protect user's data and prove that the website is trustworthy
Efficient Rendering
Resource loading Optimization
VPC / KMS / Cognito
IAM (Identity fo AWS)
Security
HTTPS
Network Config
Configuration & Dependencies Management
DDOS Protection (CloudFlare)
Dependencies tracking & upgrade
Service configuration tracking and update
Dependency vulnerability tracking
SwiftUI
SLOs
(Service Level Objectives)
Monitoring
Chaos Engineer
(Flientd, Splunk, etc.) Logging
(NewRelic, Dynatrace) App Performance
System perfomance
Error Budgets
Incident Management & Postmortems
DevOps LifeCycle
Plan
Code
Build
Test
Release
Deploy
Operate
Monitor