Learning
  • Software Engineering Golden Treasury
  • Trail Map
  • Caching
    • Alternatives to use before using cache
    • Caching Architecture
    • Cache Invalidation and Eviction
    • Cache Patterns
    • Cache
    • Consistency
    • Distributed Caching
    • Issues with caching
    • Types of caches
  • Career
    • algo types
    • Backend Knowledge
    • Burnout
    • consultancy
    • dev-level
    • Enterprise Developer
    • how-to-get-in-tech-from-other-job
    • how-to-get-into-junior-dev-position
    • induction
    • Interview
    • junior
    • mid
    • New Job
    • paths
    • Principle/staff Engineer
    • Requirements for job
    • Senior Dev capabilities
    • learning
      • automating-beginner
      • company1
        • analyst-progression
        • core-eng-progression
        • dev-progression
        • perf-eng-progression
        • soft-deliv-progression
    • mentoring
      • mentor-resources
    • recruitment
      • questions
      • Spotting posers
  • Computer Science
    • boolean-algebra
    • Compiler
    • Finite State Machine
    • Hashing
    • Algorithms
      • Breadth Firth Search
      • complexity
      • Depth First Search
      • efficiency
      • Sliding Window
      • sorting
    • data-structures
      • AVL Trees
      • data-structures
      • Linked List
    • machines
      • Intel Machine
      • Turing Machine
      • von neumann machine
      • Zeus Machine
  • devops
    • The 5 Ideals
    • microservice
    • Artifact repository
    • Bugs and Fixes
    • Build police
    • cloud-servers
    • Deployments
    • Environments
    • GitOps
    • handling-releases
    • infrastructure-as-code
    • System Migrations
    • SDP
    • On Premises Hosting
    • Properties/configuration
    • Release process
    • Release
    • Roll Outs
    • serverless
    • Serverless
    • Cloud Services
    • Versioning
    • AWS
      • deploy-docker-esc
      • cloud-practitiioner-essentials-notes
        • Module 1 - Intro to AWS
        • Module 2 Compute in the cloud
        • Module 3 Global Infrastructure and Reliability
        • Module 4 Networking
        • Module 5 Storage and Databases
        • Security
        • 7 Monitoring and Aanlytics
        • 8 Pricing and Support
        • 9 Migration and Innovation
      • developer-associate
        • AWS Elastic Beanstalk
    • build-tools
      • Managing dependecies
      • Apache ANT
      • Gradle
        • Custom Plugins
        • local-jars
      • Project Management - maven
        • Archtypes
        • Build Lifecycles
        • Customising build lifecycle
        • Dependencies
        • Directory layout
        • jar-files
        • one-to-one
        • Modules
        • Phases
        • Maven Plugins
        • POM
        • profiles
        • setup
        • Starting a maven project
        • wrapper
    • CI/CD
      • Continuous Delivery
      • zookeeper
      • Continuous Integration (CI)
      • github-actions
      • Pipeline
      • Teamcity
    • Cloud computing
      • Overview
      • Service Models
      • Cloud Services
    • containers
      • Best Practices
      • Docker
    • Infrastructure
      • IT Infrastructure Model
      • Non functional Attributes (Quality Attributes)
        • Infrastructure Availability
        • Performance
        • Secruity
    • monitoring
      • Alerting
      • Monitoring & Metrics
      • Metrics
      • Ready pages
      • Splunk
      • Status pages
      • notes-devops-talk
      • logging
        • logging
        • issues
        • Logging
        • Logging
    • Service mesh
      • Service Discovery
      • Istio
    • Terraform
    • container-management
      • Kubernetes
        • commands-glossary
        • OLTP
        • config-maps
        • Links
        • ingress
        • SDP
        • minikube
        • filter
        • indexes
        • sidecar
        • continuous-deployment
  • General Paradigms
    • CAP theorem
    • designing data-intensive applications summary
    • a-philosophy-of-software-design-notes
    • Aspect oriented Programming (AOP)
    • Best Practice
    • Cargo Cult
    • Clean Code
    • Coding reflections
    • Cognitive Complexity
    • Complexity
    • Conventions
    • Design discussions
    • Design
    • Error Handling Checklist
    • Exceptions
    • Feature Flags/toggle
    • Functional requirements
    • Last Responsible Moment
    • Lock In
    • Named Arguments
    • Naming
    • Performance Fallacy
    • Quality
    • Redesign of a system
    • Resuse vs Decoupling
    • Rules for software designs
    • Sad Paths
    • Scaling Webservices
    • Scientific Method
    • stream-processing
    • Upstream and Downstream
    • Patterns
      • Client-SDK-Pattern
      • ORM
      • Api gateway
      • Business Rules Engine
      • cache
      • Composition Root
      • Dependency Injection Containers
      • Dependency Injections
      • Double Dispatch
      • Exception Handling
      • Gateway pattern
      • Humble Object
      • Inheritance for reuse
      • Null Object Pattern
      • Object Mother
      • Patterns
      • Collection pipeline pattern
      • Service Locator
      • Setter constructor
      • Static factory method
      • Step Builder Pattern
      • telescopic constructors
      • Toggles
      • API
        • Aims of API designs
        • Avoid Checked Exceptions
        • Avoid returning nulls
        • Be defensive with your data
        • convience-methods
        • Fluent Interfaces
        • Loan Pattern
        • prefer-enums-to-boolean-returns
        • return-meaningful-types
        • Small intefaces
        • Support Lambdas
        • Weakest type
      • Gang of Four
        • Builder
        • Factory Pattern
        • Strategy Pattern
        • Template
        • abstract Factory
        • Adapter
        • Bridge Pattern
        • Chain of responsibility
        • Command Pattern
        • Composite Design Pattern
        • Decorator Pattern
        • Facade Pattern
        • Flyweight pattern
        • Guard Clause
        • Interpreter
        • html
        • Mediator Pattern
        • Memento Pattern
        • Observer
        • Prototype
        • Proxy
        • Singleton
        • State Pattern
        • Visitor Pattern
    • Architecture
      • Entity Component System
      • Integration Operation Segregation Principle
      • Adaptable Architecture
      • Architecture
      • C4 Modelling
      • cell-based
      • Clean/Hexagonal Architecture
      • Codifying architecture
      • Correct By configuration
      • Cost Base Architecture
      • Data Oriented Design
      • deliberate
      • Domain oriented DOMA
      • Event Driven Architecture
      • Evolutionary Architecture
      • examples
      • Feature Architecture
      • Framework and Libraries
      • functional-core-imperative-shell
      • Layered Architecture
      • Micro services
      • monoliths-to-services
      • Multi tiered Architecture
      • Multi tenant application
      • Resilient Architecture
      • stage event driven architecture (SEDA)
      • links spring rest app
      • Tomato Architecture
      • Tooling
      • Types of architecture
      • checklist
        • Checklist for new project
        • Back end Architecture Checklist
        • Front end Architecture Checklist
        • Mobile Architecture Checklist
      • Cloud Patterns
        • Command and Query Responsibility Segregation (CQRS)
        • Event Sourcing & CQRS
        • Asynchronous Request and Reply
        • Circuit Breaker
        • Retry
        • Sidecar
        • Strangler pattern
      • Domain driven design
        • value & entity
      • Microservices
        • Alternatives to choosing microservices first when scaling
        • Consistency in distributed systems
        • 12 Factor applications
      • Modularity
        • Module monolith vs Microservices
        • Spring Moduilth
      • Architecture Patterns
        • Hexagonal architecture
        • Inverting dependencies
        • Layering & Dependency Inversion Principle
        • Mappings
        • Vertical Slice architecture
        • Web Client Server
        • domain
          • Business and Data Layers Separation
          • DTO
          • Domain Model Pattern
          • Domain Object
          • Transaction Script/ Use Case pattern
        • Enterprise Patterns
          • Concurrency
          • Distribution strategies
          • Domain layer patterns
          • Layering/organisation of code
          • Mapping to datasource
          • Session State
        • Usecases
          • Use case return types
      • Serverless
        • Knative
    • Design architecture aims
      • back of envelope
      • Design ideas
      • Design mistakes
      • high-volume-design
      • ISO Quality Attributes
      • Non functional requirements
      • “Designing for Performance” by Martin Thompson
      • High Performance
      • Qaulity Attributes
        • Availability
        • System Availability
        • Fault Tolerance
        • interoperability
        • Latency
        • Maintability
        • Modifiability
        • Performance
        • Readability
        • Reliability
        • Scalability vs performance
        • Scalability
        • Scaling
        • statelessness
        • Testability
        • Throughput
      • System Design
      • web-scalability-distributed-arch
        • scalable-and-distributed-web-architecture
    • README
      • Conflict-free Replicated Data Type
      • Fallacies
      • Load balancing
      • Rate Limiting
      • Transactions
    • Patterns of Enterprise Application Architecture
      • Repository Pattern
      • Rules Engines
      • scatter-gather
      • Specification Design Pattern
      • Table Driven Development
      • Workflow Design Patterns
        • Triggers
    • Principles
      • Do It Or Get Bitten In The End
      • Dont Repeat Yourself
      • Habitability
      • Keep it simple
      • Responsibility Driven Design
      • Ya Ain’t Gonna Need It
      • Conceptual Overhead
      • CUPID
      • Reuse existing interfaces
      • Facts and Fallacies
      • locality of behaviour
      • Separation of Concerns
      • Simplicity
      • SLAP principle
      • Step down rule
      • Unix Philosophy
      • Wrong abstractions
      • SOLID
        • 1. Single Responsibility Principle
        • 2. Open Close Principle
        • 3. Liskov Substitution Principle
        • 4. Interface Segregation Principle
        • 5. Dependency Inversion Principle
        • GRASP (General Responsibility Assignment Software Principles)
        • Solid for packages
          • jobs
          • CCP
          • CRP
          • REP
          • egress
          • gossip-protocol
        • STUPID
    • programming-types
      • Coding to Contract/Interface
      • Links
      • Declarative vs Imperative Programming Languages
      • defensive-programming
      • Design by contract
      • Domain Specific Languages (DSL)
      • Event Driven
      • file-transfers
      • Logical Programming
      • Mutability
      • Self Healing
      • Simplicity
      • Type Driven Design
      • Value objects
      • Aspect Oriented Programming
      • Concurrent and Parallel Programming
        • Actor Model
        • Asynchronous and Synchronous Programming
        • Batch processing
        • Concurrency Models
        • SAP
        • Multithreading
        • Non Blocking IO
        • Optimistic vs Pessimistic Concurrency
        • Thread per connection or request model
        • Actor
        • aysnchronous-tasks
          • Computational Graphs
          • Divide and conquer
          • Future
          • Thread Pool
        • barriers
          • Barriers
          • Race conditions
        • design
          • agglomeration
          • Communication
          • Mapping
          • Partitioning
        • Liveness
          • Abandoned Lock
          • Deadlocks
          • Livelock
          • Starvation
        • locks
          • Read write lock
          • Reentrant lock
          • Try Lock
        • Mutual Exclusion
          • Data Races
          • Mutual Exclusion AKA Locks
        • performance
          • Amdahl's Law
          • Latency, throughput & speed
          • Measure Speed up
        • synchronization
          • Condition variable
          • producer consumer pattern
          • Semaphore
        • Threads and processes
          • Concurrent and parallel programming
          • Daemon Thread
          • Execution Scheduling
          • sequential-parallel
          • Thread Lifecycle
          • threads-and-processes
      • Functional Programming
        • Currying
        • design-patterns-to-func
        • imperative-programming
        • First class functions
        • Functional Looping
        • Higher Order Functions
        • Immutability
        • Issues with functional Programming
        • Lambda calculus
        • Lazy & Eager
        • map
        • Monad
        • Railway Programming
        • Recursion
        • Reduce
        • referential-transparacy
        • Referential transparency
        • Supplier
      • oop-design
        • Issues with object oriented code
        • Aggregation
        • Anti Patterns
        • Association
        • class-and-objects
        • Composition
        • general-laws-of-programming
        • general-notes
        • Getters and Setters
        • Inside out programming
        • Inversion of control
        • oop-design
        • Other principles
        • Outside in programming
        • Readability
        • Why OO is bad
        • README
          • abstraction
          • encapsulation
          • inheritance
          • Polymorphism
        • clean-code
          • Code Smells
          • Comments
          • Naming
          • CLEAN design
            • code is assertive
            • Cohesion
            • Connascence
            • Coupling
            • Encapsulation
            • Loose Coupling
            • Nonredundant code
      • Reactive Programming
        • reactive-programming
    • Projects and Software types
      • Applicatoin Development
      • Buying or creating software
      • Console Applications
      • Embedded Software development
      • Enterprise
      • Framework Development
      • Games
      • Library development
      • Rewriting
      • White Label Apps
    • State Machines
      • Spring State Machine
  • Other
    • 10x devs
    • Aim of software
    • Choosing Technologies
    • Coding faster
    • Component ownership
    • developer-pain-points
    • Developer Types
    • Effective Software design
    • Full Stack Developer
    • Good coder
    • Issues with Software Engineering and Engineers
    • Learning
    • Logic
    • Role
    • Software Actions
    • Software craftmanship
    • Software Designed
    • Software Engineering
    • Software
    • article-summaries
      • General notes
      • Summary of The Grug Brained Developer A layman's guide to thinking like the self-aware smol brained
      • improve-backend-engineer
      • Optimising Api
      • Simple and Easy
    • README
  • Hardware
    • Cpu memory
    • Storage
  • Integration
    • GRPC
    • API
    • Apis and communications between apps
    • asynchronous and synchronous communications
    • Batch Processing
    • Communications between apps
    • Delivery
    • Distributed Computing
    • Entry point
    • Event Source
    • SDP
    • egress
    • Graphql
    • Idempotency
    • Libraries
    • Long Polling
    • Multiplexing & Demultiplexing
    • Publish Subscribe
    • Push
    • Request & Response
    • REST
    • Remote Method Invocation
    • Remote Procedure Calls
    • Server Sent Events
    • Short Polling
    • Sidecars
    • SOAP
    • Stateless and Stateful
    • Streams
    • Third Party Integrations
    • wdsl
    • Web Services
    • Webhooks
    • repository
    • Kafka
      • Kafka Streams
    • message-queues
      • ActiveMQ
      • Dead Letter Queue
      • JMS
      • Messaging
  • Languages
    • C
    • Choosing A Language
    • cobol
    • Composite Data Types
    • creating
    • Date time
    • Numbers
    • Pass by value vs Pass by reference
    • Primitive Data Types
    • REST anti-patterns
    • Rust
    • Scripting
    • Static typing
    • string
    • Task Oriented Language
    • assembly
    • Getting started
      • Functional Concepts
    • cpp
    • Java
      • Code style
      • Garbage Collection
      • Intellij Debugging
      • Artifacts, Jars
      • Java internals
      • Java resources
      • Java versions
      • JShell
      • Libraries
      • opinionated-guide
      • Starting java
      • Java Tools
      • Why use java
      • Advanced Java
        • Annotations
        • API
        • Database and java
        • Debugging Performance
        • Files IO
        • Finalize
        • JDBC
        • jni
        • Libraries
        • Logging
        • SAP
        • Memory Management
        • Modules
        • OTher
        • Packaging Application
        • Pattern matching
        • performance
        • Properties
        • Reference
        • reflection
        • Scaling
        • Scheduling
        • secruity
        • Serilization
        • Time in Java
        • validation
        • Vector
        • Concurrency and Multithreaading
          • Akka
          • ExecutorCompletionService
          • Asynchronous Programming
          • Concurrency and Threads
          • CountDownLatch
          • Conccurrent Data Structures
          • Executor Service
          • Futures
          • reactive
          • Semaphore
          • structured concurrency
          • Threadlocal
          • Threads
          • Virtual Threads
          • Mutual Exclusion
            • Atomic
            • Synchronized
            • Thread safe class
            • Threads
        • debug
          • heap-dumps
          • thread-dumps
        • functional
          • Collectors
          • Exception Handling
          • Flatmap
          • Functional Programming
          • Generators
          • Immutability
          • issues
          • Optional
          • Parallel Streams
          • Reduce
        • networks
          • HTTP client
          • servlet-webcontainers
          • sockets
          • ssl-tls-https
      • Basics of java
        • compilation
        • computation
        • Conditonal/Flow control
        • Excuting code
        • Instructions
        • Looping/Iterating
        • memory-types-variables
        • methods
        • Printing to screen/debugging
        • Setup the system
        • Data structures
          • Arrays
          • Arayslist/list
          • Map
      • Effective Java notes
        • Creating and Destroying Objects
        • Methods Common to All Objects
        • best-practice-api
        • Classes and Interfaces
        • Enums and Annotations
        • Generics
      • framework
        • aop
        • bad
        • Dagger
        • Databases
        • Lombok
        • Mapstruct
        • netty
        • resliance4j
        • RxJava
        • Vert.x
        • Spring
          • Spring Data Repositories
          • actuator
          • cloud-native
          • H2 Db in Spring
          • Initializrs
          • JDBC Template
          • Java Persistence API (JPA)
          • kotlin
          • Pitfalls and advice
          • PRoxies
          • Reactive
          • spring security
          • spring-aop
          • Spring Boot
          • spring-jdbc
          • Spring MVC
          • Spring Testing
          • Testing
          • Transaction
          • patterns
            • Component Scan Patterns
            • Concurrency
            • Decorator Pattern in Spring
        • Micronaut
          • DI
        • Quarkus
          • database
          • Links
      • Intermediate level java
        • String Class
        • Assertions
        • Casting
        • Clonable
        • Command line arguments
        • Common Libraries/classes
        • Comparators
        • Where to store them?
        • Shallow and Deep Copy
        • Date and Time
        • Enums
        • Equals and Hashcode
        • Equals and hashcode
        • Exceptions
        • Final
        • Finally
        • Generics
        • incrementors
        • Null
        • packages and imports
        • Random numbers
        • Regex
        • Static
        • toString()
        • OOP
          • Accessors
          • Classes
          • Object Oriented Programming
          • Constructors
          • Fields/state
          • Inheritence
          • Interfaces
          • Methods/behaviour
          • Nested Classes
          • Objects
          • Static VS Instance
          • Whether to use a dependency or static method?
        • Other Collections
          • Other Collections
          • Arraylist vs Linkedlist
          • LinkedHashMap
          • Linked List
          • Priority queue
          • Sequenced Collections
          • Set
          • Shallow vs Deep Copy
          • Time Complexity of Collections
          • What Collection To use?
    • kotlin
      • Domain Specific Language
      • learning
      • Libraries
      • Personal Roadmap
      • Links
    • Nodejs
      • Performance
  • Management & Workflow
    • Agile
    • Take Breaks
    • # Communication
    • Engineering Daybook
    • Estimates
    • Feedback Loops
    • Little's law
    • Managing Others
    • poser.
    • Presentations
    • self-improvement
    • software-teams
    • Task List
    • trade-off
    • Types of devs
    • Type of work
    • Waterfall Methodology
    • coding-process
      • Bugs
      • Code Review
      • Code Reviews
      • Documentation
      • Done
      • Handover
      • Mob Programming
      • Navigate codebase
      • Pair Programming
      • Pull Requests
      • How to do a story
      • Story to code
      • Trunk based development
      • Xtreme Programming (XP)
      • debugging
        • 9 Rules of Thumb of Dubugging
        • Debugging
        • using-debugger
      • Legacy code
        • Legacy crisis
        • Working with legacy code
    • Managing work
      • Theory of constraints
      • Distributed Teams
      • estimations
      • Improving team's output
      • Kanban
      • Kick offs
      • Retrospectives
      • Scrum
      • Sign offs
      • Stand ups
      • Time bombs
      • Project management triangle
    • Notion
    • recruitment
      • In Person Test
      • Interviews
      • Unattended test
  • Networks
    • Content Delivery Network - CDN
    • DNS
    • cache control
    • Cookies and Sessions
    • Docker Networking
    • Duplex
    • Etags
    • HTTP Cache
    • HTTP - Hyper Text Transfer Protocol
    • HTTP/2
    • Http 3
    • Internet & Web
    • iptables
    • Keep alive
    • Leader Election
    • Load balancer
    • long-polling
    • Network Access Control
    • Network Address Translation (NAT)
    • Network Layers
    • Nginx
    • OSI network model
    • Persistent Connection
    • Polling
    • Proxy
    • Quic
    • reverse-proxy
    • servers
    • Server sent events (SSE)
    • SSH
    • Streaming
    • Timeouts
    • Url Encoding
    • Web sockets
    • WebRTC (Web Real-Time Communication)
    • Wireshark
    • tcp/ip
      • Congestion
      • IP - Internet Protocol
      • TCP - Transmission Control Protocol
  • Operating Systems
    • Cloud Computing
    • Distributed File Systems
    • Distributed Shared Memory
    • Input/Output Management
    • Inter-Process Communication
    • Threads and Concurrency
    • Virtualization
    • Searching using CLI
    • Bash and scripting
    • Booting of linux
    • makefile
    • Memory Management
    • Processes and Process Management
    • Scheduling
    • Scripting
    • Links
    • Ubuntu
    • Unix File System
    • User groups
    • Linux
  • Other Topics
    • Finite state machine
    • Floating point
    • Googling
    • Setup
    • Unicode
    • Machine Learning
      • Artificial Intelligence
      • Jupyter Notebook
    • Blockchain
    • Front End
      • Single Page App
      • cqrs
      • css
      • Debounce
      • Dom, Virtual Dom
      • ADP
      • htmx
      • Island Architecture
      • Why use?
      • Java and front end tech
      • mermaidjs
      • Next JS
      • javascript
        • Debounce
        • design
        • Event loop
        • testing
        • Typescript
        • react
          • Design
          • learning
          • performance
          • React JS
          • testing
      • performance
      • Static website
    • jobs
      • Tooling
      • bash text editor - vim
      • VS code
      • scaling
        • AI Assistant
        • Debugging
        • General features and tips and tricks
        • IDE - Intellij
        • Plugins
        • Spring usage
  • persistance
    • ACID - Atomicity, Consistency, Isolation, Durability
    • BASE - Basic Availability, Soft state, Eventual Consistency
    • Buffer
    • Connection pooling
    • service
    • Database Migrations - flywaydb
    • Databases
    • Eventual Consistency
    • GraphQL
    • IDs
    • indexing
    • MongoDB
    • Normalisation
    • ORacle sql
    • Partitioning
    • patterns
    • PL SQL
    • Replication and Sharding
    • Repository pattern
    • Sharding
    • Snapshot
    • Strong Consistency
    • links
    • Files
      • Areas to think of
    • hibernate
      • ORM-hibernate
    • Indexes
      • Elastisearch
    • relationships
      • many-to-many
      • SDP
      • serverless
      • x-to-x-relationships
    • sql
      • Group by
      • indexes
      • Joins
      • Common mistakes
      • operators
      • performance
    • types
      • maven-commands-on-intellij
      • in-memory-database-h2
      • Key value database/store
      • Mongo DB
      • NoSQL Databases
      • Relational Database
      • Relational Vs Document Databases
  • Security
    • OAuth
    • API Keys
    • Certificates and JKS
    • Cluster Secruity
    • Communication Between Two Applications via TLS
    • Cookies & Sessions
    • CORS - Cross-Origin Resource Sharing
    • csrf
    • Encryption and Decryption
    • Endpoint Protection
    • JWT
    • language-specific
    • OpenID
    • OWASP
    • Secrets
    • Secruity
    • Servlet authentication and Authorization
    • vault
  • Testing, Maintainablity & Debugging
    • Service-virtualization and api mocking
    • a-test-bk
    • Build Monitor
    • Builds
    • Code coverage
    • consumer-driven contract testing
    • Fixity
    • Living Documentation
    • Mocks, Stubs & Doubles
    • patterns
    • Quality Engineering
    • Reading and working with legacy code
    • Reading
    • remote-debug-intellij
    • simulator
    • Technical Debt
    • Technical Waste
    • Test cases
    • Test Data Builders
    • Test Pyramids
    • Test Types
    • Testing Good Practice
    • Testing
    • What to prime
    • What to test
    • Debugging
      • Debugging in kubernetes or Docker
    • fixing
      • How to Deal with I/O Expense
      • How to Manage Memory
      • How to Optimize Loops
      • How to Fix Performance Problems
    • Legacy Code
      • Learning
      • Legacy code
      • techniques
    • libraries
      • assertj
      • Data Faker
      • Junit
      • mockito
      • Test Containers
      • Wiremock
      • Yatspec
    • Refactoring
      • Code Smells
      • refactoring-types
      • Refactoring
      • Technical Debt
      • pyramid-of-refactoring
        • Pyramid of Refactoring
    • Test first strategies
      • Acceptance Testing Driven Developement (ATDD)
      • Behaviour Driven Development/Design - BDD
      • Inside out
      • Outside in
      • Test driven development (TDD)
    • testing
      • Acceptance tests
      • How Much Testing is Enough?
      • Approval Testing
      • Bad Testing
      • End to end tests
      • Honeycomb
      • Testing Microservices
      • Mutation testing
      • Property based testing
      • Smoke Testing
      • social-unit-tests
      • solitary-unit-tests
      • Static Analysis Test
      • Unit testing
  • Version Control - Git
    • Branch by Abstraction
    • feature-branching
    • Git patches
    • Trunk Based Development
Powered by GitBook
On this page
  • Core Engineer Progression
  • --Engineering--
  • Primary Programming Language (OO or FP)
  • Secondary Programming Language (OO or FP)
  • Testing
  • Good Coding Practice (& Design Patterns/SOLID principles)
  • Technical Decision Making
  • Technology Strategy
  • Debugging of Production Issues
  • Performance Optimisation & Scalability
  • Continuous Deployment
  • Security
  • Security
  • Monitoring & Analytics
  • Automation
  • Requirements Gathering
  • Performance Testing in Continuous Deployment
  • Containerisation
  • Software Managed Infrastructure
  • Unix
  • -- Customer --
  • Customer Focus and Value
  • Business Value
  • Strategy
  • -- People Culture --
  • Contribute to Agile Practices
  • Domain Knowledge
  • Technical Leadership
  • Growing the Team
  • Communication
  • Identifying Opportunities for Improvement
  • Community
  • Industry Insight

Was this helpful?

  1. Career
  2. learning
  3. company1

core-eng-progression

Previousanalyst-progressionNextdev-progression

Last updated 3 years ago

Was this helpful?

Core Engineer Progression

--Engineering--

Primary Programming Language (OO or FP)

Overall knowledge of the language; its style, ecosystem, strengths and weaknesses.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Be able to read and understand code written by yourself and others, with the ability to and make simple changes Understand the ecosystem (package managers, task runners, development tools etc) Have some familiarity with debugging tools 3 - Practice Able to work independently, maybe working on own project Refactor existing code to improve its design Actively research for new ideas and technologies Understand the different paradigms of the language (e.g OOP, FP) 4 - Drive/Lead Ability to focus on Non Functional Aspects (e.g performance , resiliency etc.) Mentor others learning the language Understand the relative strengths and weaknesses of the language and which design patterns do/do not work well. Write idiomatic and clean code Good knowledge of 3rd party tools - what to use and why. Evaluate “up and coming” frameworks and tools for fit. 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Secondary Programming Language (OO or FP)

Overall knowledge of the language; its style, ecosystem, strengths and weaknesses.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Be able to read and understand code written by yourself and others, with the ability to and make simple changes Understand the ecosystem (package managers, task runners, development tools etc) Have some familiarity with debugging tools 3 - Practice Able to work independently, maybe working on own project Refactor existing code to improve its design Actively research for new ideas and technologies Understand the different paradigms of the language (e.g OOP, FP) 4 - Drive/Lead Ability to focus on Non Functional Aspects (e.g performance , resiliency etc.) Mentor others learning the language Understand the relative strengths and weaknesses of the language and which design patterns do/do not work well. Write idiomatic and clean code Good knowledge of 3rd party tools - what to use and why. Evaluate “up and coming” frameworks and tools for fit. 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Testing

Testing the right things in the right way using the relevant tools. Test suite usefulness, readability, robustness and speed.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Ability to work on test automation following the conventions in place Able to write tests first and understand the value it gives Be aware of various levels of testing (e.g. unit, integration, end-to-end, performance) Be aware of different tools for users with different accessibility needs and how these are used Use an accessibility auditing tool to test front-end products 3 - Practice Understand the test pyramid, and which testing frameworks to use for each level of testing Demonstrate use of tests to drive programmatic interface design Keep test suite up-to-date, remove redundant & irrelevant tests Keep test run fast to provide quick feedback Be able to use accessibility tools such as screenreaders, voice-control, magnification settings in testing front-end products 4 - Drive/Lead Know what to test, and the value of not testing. Always consider non-functional testing (e.g. security, resiliency, performance) Mentor teams and individuals Able to choose the right level of testing for a component (e.g mocking vs true integration) 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Good Coding Practice (& Design Patterns/SOLID principles)

Writing good, clean, maintainable code that has clarity of purpose and produces products that are usable by all... and keeping it that way.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Recognise coding standards in a project and follow them Descriptive names: Method, variable, classes, etc. Awareness of Accessibility and x's Accessibility Principles and Guidelines Awareness of different types of assistive technologies 2 - Follow Write readable code and constantly improves the code base Some basic application of SOLID, DRY and YAGNI (You ain't gonna need it) Documentation of how to build and deploy the project, as well as public interfaces (including APIs) Ensure Accessibility is considered as part of the development of our products and services Use Accessibility tooling to help understand and measure our products Follow x's accessibility principles and guidelines when creating front-end products 3 - Practice Write code that can be debugged and supported in production (e.g use of logging) Follow of good practice and coding standards throughout the whole project and being able to code review against it Constantly apply refactoring on small scale as part of development SOLID, DRY, YAGNI and KISS (Keep it Simple) (Front-end) Understand and practice appropriate use of semantic elements/views and across products and services (Front-end) Understand and implement supportive technology (e.g. ARIA/roles/traits) to enhance experience and bring semantic meaning where appropriate (Front-end) Use appropriate tooling (e.g. screen readers) and audit tools to develop and test accessible products and services 4 - Drive/Lead Ability to define coding standards Understand the “why’s” of SOLID and spot edge cases where SOLID not appropriate Ability to identify areas in code that benefit from extensive refactoring Find simple solutions to complex problems Can contribute to code outside of the team or area (e.g. I-OSS) 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Technical Decision Making

The ability to make well-reasoned technical decisions taking into account all intrinsic & extrinsic factors.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand 2 - Follow Contribute to discussions about decision making Knows when a decision needs to be made and consults team members Suggesting ideas in brainstorming sessions 3 - Practice Has ability to, and sometimes does, make technical decisions independently Hold meetings, lead technical discussions for the team Use appropriate language for the audience when presenting Challenge the status quo 4 - Drive/Lead Influence technical direction based on planned future work Be aware of the broader impact of the local technical decisions Guide others rather than decide yourself Being able to compare languages/products and choosing the correct one to get the job done Consider the “people factor” 5 - Evangelise

Technology Strategy

Working towards, contributing to and devising the technology strategy.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand 2 - Follow Know the wider company and department strategy, taking that into consideration when introducing local changes 3 - Practice Hold a conversation challenging wider strategy Regularly solicit to help orient the technical strategy of the area Understand how the strategy decisions affect the technical decisions (including resource availability) Give direction according to strategy 4 - Drive/Lead Understand the wider business & market Understand how the business strategy drives the technology strategy Contribute to the vision for the wider company’s technology strategy Understand implications of technical strategy (cost/funding, timescales, problems, etc.) 5 - Evangelise

Debugging of Production Issues

Investigating and getting down to the root cause of issues using monitoring, logging, application insight and other tools.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Know where to find the tools for production monitoring and debugging. Know where the support systems are. Understand the incident management process. Understand the deployment process. Know how and when a hotfix should be implemented. Assist debugging a production issue. 3 - Practice Identify and understand the difference between HPI, MPI and P3 incidents, to appropriately classify and fix the issue. Understand the architecture of production systems. Understand how a request from a customer gets to your application and the infrastructure it passes through. Study analytics data debug and test solution. Ability to stop the same issue from happening, identify a root cause. 4 - Drive/Lead Improve the visibility of monitoring, reporting and analytics of production applications and infrastructure. Ensuring the correct data is captured to be able to adequately debug issues and propose improvements. Identify potential design and infrastructure flaws and drive the fix. Investigate and identify new tools to log and monitor issues that aid in debugging. Encourage the team to take responsibility for identify and fixing issues. 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Performance Optimisation & Scalability

The building, measuring and optimisation of systems performance.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Appreciates that it takes special attention, time and cost for performance and optimisation within systems. 2 - Follow Know the performance goals and targets of the application/infrastructure. Understand the different techniques and tools to track application performance. Understand the difference between horizontal and vertical scaling. 3 - Practice Know what to look for to benchmark applications and improve performance. Identify potential performance problems and optimise, balancing critical optimisation vs. too early optimisation. Use performance optimisation tools to identify and fix issues. Use RUM data to baseline and track improvement after fixing issues. Know the difference between planned and automatic scaling 4 - Drive/Lead Coach others in performance optimisation and the impact it can have on customers and business. Draw attention when performance is suboptimal based on industry standards and lead improvements. Implement scaling strategies to cope with known and unknown demand. 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Continuous Deployment

The streamlining and automation of integration, build and deployment; both rolling forward and reverting changes.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Know how to deliver artifacts to production. Understand different deployment methods such as blue/green and canary. 3 - Practice Setup CD workflows. Build once and deploy often. Automation is a 1st class citizen. Improve CD flows, ensure customer impact is always minimal in the event of an error. Understand how to validate a deployment. 4 - Drive/Lead Define a CD approach. Improve the visibility and monitoring of CD flows and deployments. Research improvements to CD flows. Ensure test coverage is excellent to reduce bugs getting to production. Automation is a 1st class concern for deployment and rollbacks. Use deployment validation to implement rollback. 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Security

The build and maintenance of systems supporting our security requirements.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Develop systems that follow current security practices. Awareness of OWASP and how it aids development Have a working knowledge of the team's security practices. 3 - Practice Engage with external teams & fix any issues (i.e. pen-testing). Fix security issues. Help the business understand the impact of a specific flaw. Cross reference against known OWASP vulnerabilities. 4 - Drive/Lead Define & deliver architectures that address security. Decide overall security strategy. Redesigns to eliminate classes of vulnerability . Use OWASP or other tooling. Automate scanning for vulnerabilities. 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Security

The build and maintenance of systems supporting our security requirements.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Develop systems that follow current security practices. Awareness of OWASP and how it aids development Have a working knowledge of the team's security practices. 3 - Practice Engage with external teams & fix any issues (i.e. pen-testing). Fix security issues. Help the business understand the impact of a specific flaw. Cross reference against known OWASP vulnerabilities. 4 - Drive/Lead Define & deliver architectures that address security. Decide overall security strategy. Redesigns to eliminate classes of vulnerability . Use OWASP or other tooling. Automate scanning for vulnerabilities. 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Monitoring & Analytics

The implementation and use of monitoring, logging and tracing tools accoring to risk, need and usefulness in order to promote rich insight into the behaviour and performance of our systems.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Awareness of monitoring dashboards. Awareness of analytics and how they can be used to influence business and technical decisions. 2 - Follow Use monitoring tools to set up alerts. Use analytics to aid in technical or product decisions. Integrate with monitoring and analytic tools. Ensure monitoring is visible and actively updated. 3 - Practice Identify key transactions to alert from Understand what to measure and alert on when shipping new features Analyse the data output from monitoring and analytics to understand anomalies. Push analytic evidence back into dev efforts Configure monitoring and analytics tools 4 - Drive/Lead Determine and assess relevant monitoring and analytic tools Understand how to reduce noise in monitoring 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Automation

Overall knowledge of Automation

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Appreciates that tasks for systems development can be automated. 2 - Follow Understands the basics of automation and where it is employed in current development environments. 3 - Practice Be able to read and understand code written by yourself and others, with the ability to and make simple changes Understand the ecosystem (package managers, task runners, development tools etc) Have some familiarity with debugging tools 4 - Drive/Lead Able to work independently, maybe working on own project Refactor existing code to improve its design Actively research for new ideas and technologies Understand the different paradigms of the language (e.g OOP, FP) 5 - Evangelise Ability to focus on Non Functional Aspects (e.g performance , resiliency etc.) Mentor others learning the language Understand the relative strengths and weaknesses of the language and which design patterns do/do not work well. Write idiomatic and clean code Good knowledge of 3rd party tools - what to use and why. Evaluate “up and coming” frameworks and tools for fit.

Requirements Gathering

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Be aware of Accessibility and x's Accessibility Principles and Guidelines and follow these when creating requirements Be aware of different types of users and their needs when using the products we create 2 - Follow Work with product owners, design and developers to define and identify accessibility requirements Be aware of different types of assistive technologies and how a user interacts with our products using these Ensure requirements and user stories represent users with disabilities 3 - Practice Understand what a good requirement/user story looks like Be able to use assistive technologies such as screenreaders to ensure requirements are met 4 - Drive/Lead Be able to write good user stories and acceptance criteria, using techniques such as BDD where appropriate Able to breakdown requirements into appropriate sizes Critically interrogate requirements to ensure completeness and roundedness Understand how to work with 3rd parties to ensure products we consume are accessible 5 - Evangelise Drive requirements sessions with stakeholders. Be able to run greenfield requirements sessions as well as unpicking technically complex subjects. Drive focus on value through eliciting effective requirements and context

Performance Testing in Continuous Deployment

The streamlining and automation of performance testing as part of continuous deployment; both rolling forward and reverting changes.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Understand the steps, roles and timings of a deployment flow. 2 - Follow Know how to implement performance testing as part of continuous deployment. 3 - Practice Automation is a 1st class citizen. Implement and maintain the test framework and blends for continuous deployment Understand how to validate performance test results in a deployment. 4 - Drive/Lead Define a CD approach for performance testing Improve the visibility and monitoring of performance tests during CD flows and deployments. Research improvements to CD flows. Ensure test coverage is excellent to reduce bugs getting to production. utomation is a 1st class concern for deployment and rollbacks. 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Containerisation

Working with all the aspects of containerised environments

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I can read and understand container definitions, and can make simple changes to them. I can use the available tools to inspect the contents of Kubernetes clusters. I understand the different parts of the containerisation ecosystem (container registries, Kubernetes clusters etc). 2 - Follow I can use the available tools to deploy to a containerised environment, following a design laid out by others. 3 - Practice I can identify the most appropriate workload type (e.g. deployment/job/stateful set) for a particular purpose, and define it correctly. I can help others diagnose problems with their own containers and workloads. I can make use of the appropriate parts of the containerisation ecosystem to design new applications. 4 - Drive/Lead I look for improvements we can make to our containerised environments and how we interact with them. I mentor others in how to work with containerised environments. 5 - Evangelise I look for new ways in which containerisation can be used to deliver value across the business. I educate others in x and externally about the use and benefits of containerisation. I investigate and propose new tooling to make it easier to work with containerised environments.

Software Managed Infrastructure

Using software to manage infrastructure components with minimal human operator intervention

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I understand the benefits of replacing human intervention with software to manage infrastructure. 2 - Follow I know the different software managed infrastructure components which my area uses. I can make simple changes to the software manage infrastructure components which my area uses. 3 - Practice I understand how the software managed infrastructure components used by my area work. I can introduce new software managed infrastructure components to the expected standard. 4 - Drive/Lead I drive the adoption of software managed infrastructure components within our environments. I keep abreast of industry trends in software managed infrastructure, and look for ways to take advantage of them. 5 - Evangelise I educate others within x and externally on the usage and benefits of software managed infrastructure. I look for opportunities to make improvements across x via software managed infrastructure.

Unix

Working with *nix operating systems and their ecosystem of tools

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I understand the *nix family of operating systems differs from other operating system families (e.g. OSX, Windows). I know the standard tools used in interacting with a *nix system (e.g. ps, top). 2 - Follow I can write scripts to automate basic operations. I can read and understand scripts developed by others. 3 - Practice I am confident writing scripts and know when tasks are too complex to be managed by shell scripts. I can use standard tools to diagnose problems related to memory, CPU and networking on a host. 4 - Drive/Lead I keep abreast of current industry best practice and look for ways to introduce it to my area. I understand the architecture of *nix systems and how they manage and allocate resources. I educate others in my area on how to debug and diagnose problems with a wide set of available tools. 5 - Evangelise I drive the adoption of best practice techniques and tools across the business.

-- Customer --

Customer Focus and Value

As a x employee who understands customer focus and value, I will...

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Know who your customer is Know what customer value is Be aware of the different types of users and their needs when using the products we create Be aware of Accessibility and x's Accessibility Principles and Guidelines and how these releate to our customers 2 - Follow Be aware of the customer impact of the changes I am making to my application(s) Have an understanding of different disabilities that can affect a customer's experience when accessing a product, such as Visual, Auditory, Motor and Cognitive 3 - Practice Understand the impact of happy path and unhappy path scenarios Be actively engaged as to how customers are using my application(s) Question requirements where I believe that customer value is not being considered Propose changes to my application(s) that benefit the customer Be aware of different types of assistive technologies and how a customer interacts with our products using these 4 - Drive/Lead Distinguish between customer value and business value Decide when to focus on business value and when to focus on customer value Partner with product stakeholders to define KPIs 5 - Evangelise Connect strategic product goals to technology delivery Influence product strategy through innovative use of technology Identify and share patterns from wider industry

Business Value

As a developer who...business value, I will...

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Know the company I am working for and the department I am working in Know what business value means 2 - Follow Be aware of the business impact of the changes I am making to my application(s) 3 - Practice Consider how to optimise your solution to obtain the most business value Challenge requirements where business value is not being considered 4 - Drive/Lead Be aware of the impact of change on business value through shared KPIs Decide when to focus on business value and when to focus on customer value Manage stakeholder expectations where business value is concerned Lead the team in getting a requirement to marketing quickly due to business benefit 5 - Evangelise Partner with business stakeholders to define KPIs

Strategy

As a developer who...strategy, I will...

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Know the company has a strategy Have a basic understanding of what the company strategy is 2 - Follow Know what the strategy is for the team and department I am working in Help the team implement its objectives and goals based on the business strategy 3 - Practice Implement the team strategy in technical decision making Contribute to the direction of the department strategy 4 - Drive/Lead Drive the team in developing objectives and goals based on the business strategy for the team and department Connect strategic business goals to technology strategy 5 - Evangelise Influence business strategy through innovative use of technology

-- People Culture --

Contribute to Agile Practices

Helping to maintain and grow the agility of x as both a change-delivery organisation and as a business.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Show a keenness to appreciate and learn more 2 - Follow Know the key values and principles of agile Recognise how agile benefits the delivery of work 3 - Practice Live out the key agile values and principles Take the initiative to help the team use key agile principles in the development of software, e.g. regular releases, effective collaboration and communication, iterative development, understands and helps define MVPs 4 - Drive/Lead An agile thinker and leader within the wider team Works with stakeholders to break down work and focus on delivering value 5 - Evangelise Contributes regularly to the agile community, via organising events or speaking Speaks at relevant internal and external conferences

Domain Knowledge

As a developer who...domain knowledge, I will...

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Appreciates that a knowledge of the domain is critical for productivity. 2 - Follow Demonstrates a keenness to expand knowledge of your domain 3 - Practice Pro-actively researches the domain to increase knowledge Able to explain domain to stakeholders and colleagues (in both technical and non-technical ways) Striving to develop a greater understanding as to how my domain fits within x 4 - Drive/Lead Able to share and explain x’s wider domain to stakeholders and peers in technical and non-technical ways Able to share this knowledge via communities and events with peers 5 - Evangelise Breaks down barriers and silos in sharing domain knowledge

Technical Leadership

As a x employee who exhibits technical leadership, I will...

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Be able to help new members of the team understand the application(s) related to them 3 - Practice Be able to mentor and guide other members of the team on work and technical tasks (e.g. by pair programming) Suggest technical improvements to the application(s) I work on (e.g. new technologies, accessibility improvements, app improvements etc…) Be able to influence how work is technically developed in the team Contributing to technical innovation Attends and contributes to wider departmental technical meetings Involved in relevant communities (E.g: Accessibility Champions network) 4 - Drive/Lead Organises and leads wider departmental technical meetings Able to influence and have a say in the technical direction of a department or area Helps to define team norms and practices Promote technical innovation Contributes heavily to relevant communities 5 - Evangelise Speaks at relevant internal and external conferences Leads the technical direction for a department or area

Growing the Team

As a developer who...growing the team, I will...

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand I know the basics of what this is and why it's important but have not had much practical experience. 2 - Follow Be a positive team member supporting a great working culture Assist in reviewing developer CVs for recruitment Support team events and workshops, such as brown bags, talks, knowledge sharing etc 3 - Practice Support my colleagues in all things team related (e.g. help facilitate retros, planning, stand up) Be able to listen to your peers and work together to propose solutions Comfortable assessing potential candidates during recruitment by means of pairing exercises and interviews 4 - Drive/Lead Mentors fellow developers in technical and non-technical skills Identifies opportunities to share and collaborate outside of the team Works with colleagues to set up objectives and goals Recognise skill gaps in team and drives career development and/or recruitment accordingly Identifies career growth opportunities for colleagues both in and outside the team 5 - Evangelise I Influence and evangelise both within the company and publicly. I Identify the next generation of experts and foster them.

Communication

As a x employee who exhibits good communication, I will...

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Understand why communication is important to the success of a team Understand the need to cater for different user needs when communicating 2 - Follow Explain to fellow colleagues what I have done and what I will be doing Feedback and contribute to retrospectives and planning sessions 3 - Practice Represent my team in technical, stakeholder or business meetings Be able to clearly feedback to my team after attending meetings Build relationships and communicate proactively with colleagues outside of your immediate team to avoid silos and improve collaboration Know how to communicate in an inclusive and accessible way. E.g. making use of recordings and transcripts in meetings, using tools to check the accessibility of documents and emails prior to disseminating 4 - Drive/Lead Facilitate meetings in order to get a clear outcome Knows when to arrange meetings or workshops with fellow colleagues to resolve a problem or gain a common understanding Writes blog posts 5 - Evangelise Present to Senior Leadership External blog posts Communicate complex ideas/problems into simple, easily understandable ones

Identifying Opportunities for Improvement

Identifying what is required for both yourself and others around you to grow as professionals.

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Understand the benefits of continually looking for ways to improve activities, processes and best practices. 2 - Follow Can identify weaknesses in own skills and create a plan to improve (knows when to seek help) When your team has identified an opportunity for improvement, implement that new practise into your activities and provide feed back on its effectiveness. 3 - Practice Make suggestions of improvements Identifies videos and conferences to share with team Can present a case to the business to improve a technical limitation on a product Review your own and your team’s activities for opportunities for improvement, define the potential benefits and recommend to your team or line manager. Measure the effectiveness of the changes implemented. After implementation and measurement, share these improvements and communicate the benefits to other teams in your department. 4 - Drive/Lead Provide guidance to others in ways to improve technically Follows through with suggestions for improvements Know the bigger picture so can easily identify areas which can be improved Orchestrates the continuous improvements of ways of working to the wider audience Can identify tribes weaknesses and create a plan to improve Review your team’s activities with others within your department for opportunities for improvement, define the potential benefits, identify and work with allies to drive through the changes. Coordinate the measurement of the effectiveness of the changes implemented. Engage other departments to understand their processes and best practices and assess the potential benefit of bringing those elements into your own department. 5 - Evangelise Review how your department works with other departments, discuss with stakeholders from those departments and your own stakeholders to identify and prioritise improvements, create a plan of action and deliver. Develop the measurement of the effectiveness of the improvements

Community

As a developer who...Software Engineering communities, I will...

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Be aware of x’s communities Understand the benefits of communities Be aware of how to join and get involved in a community 2 - Follow Attend community events 3 - Practice Contribute to community discussions and events Contribute to running a small community or local version of a community 4 - Drive/Lead Help lead a community Sets goals and objectives for a community Leads community discussions 5 - Evangelise Create new communities Drives community attendance

Industry Insight

Level Attainment Critera (non-exhaustive) 0 - None 1 - Understand Know who competitors are 2 - Follow Understand the USP of the business 3 - Practice Follow the USP when making decisions 4 - Drive/Lead Utilise knowledge of wider industry to influence day-to-day tasks 5 - Evangelise Drive and lead changes that will increase the ability of the company to deliver against its USP.

Core Engineer Progression
--Engineering--
Primary Programming Language (OO or FP)
Secondary Programming Language (OO or FP)
Testing
Good Coding Practice (& Design Patterns/SOLID principles)
Technical Decision Making
Technology Strategy
Debugging of Production Issues
Performance Optimisation & Scalability
Continuous Deployment
Security
Security
Monitoring & Analytics
Automation
Requirements Gathering
Performance Testing in Continuous Deployment
Containerisation
Software Managed Infrastructure
Unix
-- Customer --
Customer Focus and Value
Business Value
Strategy
-- People Culture --
Contribute to Agile Practices
Domain Knowledge
Technical Leadership
Growing the Team
Communication
Identifying Opportunities for Improvement
Community
Industry Insight