Conditionals in IT Context
1st, 2nd, and 3rd conditionals used in bug reports, planning meetings, and architecture proposals.
If we merge this PR without tests, we'll introduce a regression. Grammar for IT English
Grammar taught through real IT sentences — not textbook examples. Every exercise uses vocabulary and scenarios you'll encounter at work.
187 topics
Passive Voice in Documentation
When and how to use passive constructions in technical writing, API docs, and incident reports.
The request is authenticated using a Bearer token. Modal Verbs for Recommendations
Should, could, must, might — choosing the right modal for code reviews, proposals, and risk communication.
You might want to consider caching this response. Tenses in Status Updates
Present perfect, simple past, and future tenses for sprint updates, post-mortems, and release notes.
We have deployed the fix. The service is now stable. Hedging Language
Express uncertainty, degrees of confidence, and cautious recommendations like a native English speaker.
This might be related to the memory leak we fixed last sprint. Transition Words & Cohesion
Connect ideas smoothly in technical writing: however, therefore, given that, as a result, in contrast.
The API is fast; however, it lacks proper error handling. Reported Speech in Meeting Mins
Accurately summarise what was said in meetings, standups, and design reviews.
The tech lead suggested that we refactor the auth module first. Quantifiers & Approximators
Several, numerous, a majority of, a handful of — precise quantifiers for metrics and scope discussions.
A significant portion of users are on mobile browsers. Relative Clauses in Tech Docs
Which, that, who, where — building clear technical descriptions for APIs, components, and processes.
The endpoint which handles authentication must be rate-limited. Noun Phrases & Technical Stacking
IT English uses dense noun phrases. Learn to read and write them clearly: "distributed event-driven microservice architecture".
We need a rate-limit-aware retry backoff strategy. Punctuation in Code Comments
Correct use of semicolons, colons, dashes, and parentheses in inline comments, changelogs, and docs.
// TODO: refactor this — the current approach is O(n²) Concise IT Writing (Cut the Filler)
Identify and remove redundant phrases, passive overuse, and vague language from technical writing.
In order to → To | Due to the fact that → Because Advanced Conditionals in Technical English
Mixed conditionals, inverted conditionals, and hypothetical constructions used in architecture and risk analysis.
Were we to adopt microservices, the deployment complexity would increase significantly. Passive Voice in Technical Writing (Advanced)
Advanced passive constructions for technical specifications, compliance documents, and system architecture.
The data is validated against the schema before being persisted to the database. Reporting Clauses in Technical Communication
Verbs and structures for accurately attributing ideas in meeting notes, RFCs, and design reviews.
The team agreed that caching would reduce latency by approximately 40%. Linking Words for Technical Arguments
Advanced connectors for building coherent technical arguments in proposals, postmortems, and RFCs.
Notwithstanding the latency concerns, the solution meets the SLA requirements. Hedging Language (Extended Practice)
Extended hedging practice for proposals, estimates, and risk communication in technical English.
This approach would tend to result in reduced coupling between services. Articles & Prepositions in IT Writing
Correct use of a/an/the and common prepositions in technical documentation, stack descriptions, and code comments.
Connect to the database using a connection pool. IT Compound Nouns & Abbreviations
Read and form compound nouns and abbreviations correctly in technical writing and conversation.
load balancer → load-balancer vs. load balancing; API vs. an API Dangling Modifiers in Tech Docs
Spot and fix dangling and misplaced modifiers in technical documentation, release notes, and API guides.
Having deployed the service, the logs revealed several errors. → After we deployed... Hedging Phrase Bank
Build a comprehensive set of hedging phrases for estimates, risk statements, and technical recommendations.
It is worth noting that... | There is a possibility that... | Subject to review... Sentence Clarity & Conciseness
Rewrite verbose, ambiguous, or poorly structured sentences into clear, professional technical English.
The system is experiencing a situation where... → The system... Cleft Sentences for Emphasis
Use it-cleft and wh-cleft structures to emphasise key information in incident reports and design docs.
It was the cache invalidation logic that caused the outage. Inversion for Formal Communication
Formal inversion structures for RFPs, board memos, enterprise proposals, and high-level presentations.
Not only does the solution scale, but it also reduces operational costs. Advanced Discourse Markers
Advanced connectors like notwithstanding, admittedly, albeit, and it follows that — for formal technical writing.
Albeit complex, the distributed approach offers superior fault tolerance. Complex Noun Phrases
Read, parse, and construct the dense noun-phrase stacks that dominate IT English writing.
a containerised multi-region active-active deployment strategy Advanced Prepositional Phrases
Fixed prepositional phrases used in technical writing, requirements, and business communication.
in terms of performance | with a view to reducing latency | subject to approval Question Tags in Tech Conversations
Use question tags in standups, code reviews, and technical conversations to seek confirmation and soften requests.
This endpoint handles authentication, doesn't it? Comparative Structures in Technical English
Compare technologies, approaches, and solutions using comparative and superlative structures in professional technical English.
Redis is significantly faster than a traditional relational database for caching. Concessive Clauses (Although, Even Though, Despite)
Express trade-offs and concessions in technical writing and architecture discussions using although, despite, while, and even though.
Although the latency is higher, the system is significantly more resilient. Gerunds and Infinitives in Technical Writing
Choose correctly between gerunds and infinitives in technical documentation, bug reports, and pull request descriptions.
The service failed to respond / Calling this endpoint without authentication will result in a 401. Relative Clauses in Technical Descriptions
Use defining and non-defining relative clauses to describe components, functions, and systems with precision.
The API gateway, which handles all authentication, is deployed in a separate cluster. Discourse Markers in Technical Writing
Master additive, adversative, and causal discourse markers used in ADRs, postmortems, design docs, and PR descriptions.
The migration reduces costs. However, it introduces operational complexity. Complex Sentences in Technical Documentation
Build complex sentences with dependent clauses to explain causality, conditions, and consequences in technical writing.
Because the service is stateless, horizontal scaling becomes straightforward. Subject-Verb Agreement in Technical English
Avoid common agreement errors with complex technical subjects: collective nouns, "data", "the number of", and compound subjects.
The list of endpoints is cached — not "are cached". Rhetorical Questions in Technical Presentations
Use rhetorical questions to structure technical talks, demos, and architecture walk-throughs for maximum clarity.
So why does this matter? Because every extra millisecond costs conversions. Cleft Sentences in Technical Communication
Use It-cleft and Wh-cleft structures to highlight key causes, constraints, and decisions in design docs and incident reports.
It is the cache invalidation logic that caused the outage. Apposition in Technical Descriptions
Use appositive phrases to define terms inline — essential for API docs, changelogs, and technical specifications.
The sidecar proxy, a lightweight container in the pod, intercepts all network traffic. Hypothetical Language in Technical Discussions
Express possibilities, options, and hypothetical scenarios using modal verbs and conditional structures in design discussions.
We could use Redis. If we switch to async, it would reduce p99 latency by 40%. Quantifiers in Technical Contexts
Choose the right quantifier for technical metrics, code coverage, system scope, and user impact statements.
A significant portion of requests hit the cache — not "much requests". Passive Voice in Technical Writing
Use passive voice correctly in commit messages, changelogs, post-mortems, and technical documentation.
The bug was introduced in v2.3.1 — not "Someone introduced the bug". Modal Verbs for Certainty
Choose the right modal verb — must, should, might, could, may — to express confidence levels in technical discussions.
The issue might be related to the cache layer. The deployment must have triggered it. Reported Speech in Documentation
Report what specs state, errors indicate, and meeting decisions say — with correct tense backshift and reporting verbs.
The spec states that responses should be idempotent. The error indicated that… Participle Clauses in Technical Writing
Use present, past, and perfect participle clauses to write concise, professional technical sentences.
Having reviewed the PR, I noticed three edge cases. Failing silently, the service… Conditionals in Technical Contexts
Apply if/when/unless/provided-that conditionals in documentation, runbooks, error messages, and post-mortems.
If the retry limit is exceeded, the job enters a dead-letter queue. Prepositions in IT English
Master the prepositions that go with technical verbs and nouns: deployed to, integrated with, depends on, compatible with.
The service is deployed to production and integrated with three external APIs. Abstract Nouns in Technical English
Form and use abstract nouns correctly in IT writing: scalability, maintainability, reliability, observability, configurability.
The team focused on improving the scalability of the payment service. Degree Adverbs in Technical English
Choose the right degree adverb for technical descriptions: highly scalable, significantly faster, relatively complex, increasingly common.
The new caching layer is significantly faster than the previous implementation. Technical Definitions and Defining Structures
Write clear technical definitions using "X is a [noun] that…", "X refers to…", and "X is defined as…" — essential for API docs and glossaries.
A load balancer is a component that distributes incoming network traffic across multiple backend servers. Contrast and Concession in Technical Writing
Use however, although, despite, whereas, and even though to describe trade-offs in architecture docs and design discussions.
Although the latency is higher, the system is significantly more resilient under load. Imperative Instructions in Technical Documentation
Write direct, clear instructions for CLI guides, runbooks, and setup docs: Run, Navigate, Ensure that, Note that.
Run the following command to initialise the project. Causation and Result Language
Express cause and effect in incident reports and architecture explanations: causes, as a result, consequently, leads to, results in.
The memory leak caused the service to restart every 6 hours. Comparing Technical Approaches
Use accurate comparison language in ADRs and design docs: more efficient than, less prone to errors, preferable to, outperforms.
Infrastructure as code is less prone to errors than manual server configuration. IT Verb-Noun Collocations
Master common verb-noun pairs in software development: deploy code, run tests, merge branches, raise an issue, push a commit.
Before merging, please run the tests to confirm nothing is broken. Pronoun Clarity in Technical Writing
Avoid ambiguous pronouns in technical docs: "naked this", vague "it" and "they" with multiple referents.
This causes latency. → This cache miss causes latency. Register Shifts: Docs vs Slack vs Email
Choose the right register for executive incident reports, PR descriptions, Slack replies, client emails, and ADR comments.
The service degraded. → The payment service experienced a 40% error rate degradation between 14:02 and 14:47 UTC. Sentence Variety in Technical Writing
Mix short, medium, and complex sentences to improve readability in postmortems, architecture docs, and READMEs.
The service crashed. The logs showed OOM errors. The cache had no eviction policy set. Numbers in Technical Writing
Digits vs words, percentages, ranges, and version numbers — the rules for technical contexts.
The cache size increased from 512 MB to 2 GB, reducing latency by 35%. Abbreviations in Technical Writing
Introduce abbreviations on first use, form correct plurals (APIs not API's), and choose "a" vs "an" correctly.
The application programming interface (API) returns JSON. Three APIs support this flow. Cohesion and Signposting
Guide readers through technical documents using signposting language: firstly, as discussed above, in summary, with this in mind.
Having established the root cause, we can now outline the remediation steps. Precise Word Choice
Choose precise technical vocabulary: "use" vs "utilise", "deploy" vs "implement", "O(n²)" vs "very slow".
Use the existing library. → Utilise the existing library. (Use is almost always better.) Future Forms in IT English
Will, going to, and present continuous for planning, releases, and technical decisions.
We will deploy the hotfix tonight. / We're migrating to Kubernetes next quarter. Gerunds and Infinitives in IT
Avoid using, try to implement, consider migrating, stop crashing vs stop to check — technical contexts.
Consider caching the response. / I tried to fix it but it still fails. / Remember to run migrations. Articles in Technical Writing
A, an, and the with technical nouns: an API, the database, a singleton, zero article for product names.
An API endpoint accepts an HTTP request and returns a JSON response. Conjunctions in Technical Writing
Although, despite, however, therefore, whereas in API docs, changelogs, and postmortems.
Although the latency increased, throughput improved. / The fix was deployed; however, monitoring continues. Noun Clauses in Technical Communication
"What we need is", "whether the service is running", "that the test passed" in technical communication.
What surprised the team was the memory footprint. / We need to check whether the endpoint responds. Reported Speech in Technical Communication
"The engineer said that...", "She mentioned that the build...", "They confirmed..." — reporting in postmortems and tickets.
The engineer said the service was down. / The architect confirmed that the migration had completed. Comparison Structures in Technical English
"X is faster than Y", "the more requests, the higher the latency", "as efficient as", "the least error-prone approach".
Redis is faster than PostgreSQL for caching. / The more concurrent users, the higher the memory usage. Parallel Structure in Lists
Write grammatically consistent bullet lists in READMEs, deployment checklists, PR descriptions, and API docs.
Features: ✓ Handles retries ✓ Logs errors ✓ Sends alerts (all present-tense verbs). Modal Verbs for Technical Communication
Use must, should, shall, and may precisely in specs, RFCs, and code reviews, following the RFC 2119 keyword conventions.
Clients MUST authenticate every request. Implementations SHOULD log failed attempts. Passive vs Active Voice in Documentation
Decide when to use passive and when active voice is clearer across API reference, READMEs, and blameless postmortems.
The request is authenticated using a Bearer token. / Install the dependencies before starting the server. Defining vs Non-Defining Relative Clauses
Choose between which, that, who, and where, and decide when commas are required, in precise technical documentation.
The API gateway, which handles all authentication, is deployed separately. Prepositions of Time for Deadlines
Choose between by, until, within, in, and on for deadlines, SLAs, release windows, and recurring schedules.
Merge the PR by Friday. The on-call engineer must acknowledge the incident within 15 minutes. Question Formation for Standups
Form clear wh-questions, polite indirect questions, subject questions, and tag questions for standups and clarifications.
What are you working on today? Could you tell me whether the deployment has finished? Tense Consistency in Postmortems
Keep tenses consistent and choose between past simple, past perfect, and present perfect when writing incident timelines.
By the time we noticed the alert, the disk had already filled up. Countable vs Uncountable Nouns in Tech
Handle tricky nouns such as data, software, feedback, and infrastructure, and choose the right quantifiers and verb agreement.
We deployed several pieces of software. We received a little feedback on the PR. Technical Definitions: Precision
Define technical terms precisely using 'refers to', appositive clauses, and relative clauses.
A mutex refers to a synchronisation primitive that prevents concurrent access. Passive Voice in Tech Documentation
Learn when passive voice strengthens and when active voice is clearer in API docs and guides.
The token is validated against the OAuth server. / Click Save to store your changes. Gerunds vs Infinitives in Tech Writing
Master gerunds and infinitives after common verbs and prepositions in technical contexts.
We recommend clearing the cache. / The team decided to break the monolith. Comparison and Evaluation Language
Use comparatives, superlatives, and contrast structures in technical decision making.
GraphQL is more efficient than REST for nested queries. / Kafka offers the highest throughput. Third Conditionals in Debugging
Form third conditionals for counterfactual analysis in postmortems and incident reports.
Had connection pooling been enabled, the database would not have crashed. Modal Verbs of Probability
Express degrees of certainty with must, may, might, could, and can't in technical contexts.
There must be an infinite loop. / The cache can't be the issue — we flushed it. Prepositional Phrases in IT English
Learn fixed IT phrases: at scale, in production, under load, on call, and more.
The system performs well at scale. / The engineer is on call this weekend. Emphasis Structures in Technical Writing
Use cleft sentences, fronting, and inversion to add emphasis in technical writing.
It is the N+1 query problem that causes the slowdown. / What we need is a circuit breaker. Discourse Markers for Technical Presentations
Structure technical talks with signposting, summarising, contrasting, and concluding markers.
Moving on from the overview... / To recap, we covered three points. / On balance... Articles with Technical Terms
Use a, an, the, and zero article correctly with technical terms and abbreviations.
We need an SSL certificate. / We deployed Kubernetes to manage our containers. Scope Markers in Technical Specifications
Use all, any, no, every, and both precisely in access control policies, specs, and API documentation.
All requests must include a valid token. / No unauthenticated calls are permitted. Sequence Connectors in Procedures
Connect steps clearly using first, then, subsequently, finally, and once in runbooks and deployment guides.
First, drain the node. Then apply the patch. Finally, verify the cluster status. Purpose and Result Clauses
Choose between to, so that, in order to, therefore, and consequently in technical writing.
We cache responses so that downstream services are not overloaded. Ergative Verbs in Technical Writing
Use agentless constructions (the server starts, the build fails) correctly in documentation and incident reports.
The migration ran successfully. / The container crashed with exit code 137. Time Clauses in Technical Procedures
Use when, once, as soon as, until, and after correctly in procedural and conditional technical writing.
Once the pod is ready, the service will start routing traffic. Comment Clauses in Technical Communication
Use as expected, note that, bear in mind, and it is worth noting to frame observations professionally.
Note that this endpoint is rate-limited to 100 requests per minute. Information Density in Technical Writing
Calibrate sentence density for READMEs, API docs, ADRs, and Slack messages.
The cache miss rate increased, triggering an alert. vs splitting into two sentences. Complex Noun Phrases in IT
Parse and write compound nouns and pre-modification stacks common in technical documentation.
container runtime security policy enforcement mechanism Zero and First Conditionals in Technical Docs
Use zero conditionals for system behaviours and first conditionals for predictions in documentation.
If memory exceeds the limit, the OOM killer terminates the process. Active vs Passive: Deliberate Choice
Deliberately choose active or passive voice for runbooks, post-mortems, and API docs.
Active: The engineer deployed the fix. / Passive: The fix was deployed at 14:32 UTC. Technical Metaphors & Analogies
Learn how native English speakers use metaphors and analogies in technical writing: "the system is drowning in requests", "refactoring debt is like compound interest".
The codebase is a house of cards — one change can bring everything down. Anaphora in Technical Documentation
Use pronouns, demonstratives, and referential expressions correctly to avoid repetition while maintaining clarity in technical docs.
The function takes a callback. It must be asynchronous and resolve within 5 seconds. Negative Structures in Technical English
Master negation patterns: not only, neither/nor, no longer, unless, without — as used in API docs, bug reports, and architecture decisions.
Neither the primary nor the fallback endpoint responded within the timeout window. Stance Markers in Technical Writing
Use epistemic and attitudinal markers (arguably, surprisingly, importantly, notably) to signal your perspective in design docs and postmortems.
Importantly, the service must not store PII beyond the processing window. Passive Nominalisation in Technical Prose
Convert verbal processes into noun phrases for formal technical writing: "the deployment was performed" → "the deployment", "we validated" → "validation".
Validation of the schema occurs before insertion into the database. Formal Negatives in IT English
Use formal negative constructions (fail to, lack, absence of, insufficient, none of) in technical reports, SLAs, and incident summaries.
The endpoint lacks rate limiting, making it vulnerable to abuse. Coordination in Technical Lists
Coordinate clauses and list items correctly using and, or, but, both/and, either/or, not only/but also in technical specifications and docs.
The service must be both stateless and horizontally scalable. It-Cleft and Extraposition
Use "It is X that..." and extraposition ("It is important to note that...") for emphasis and topic management in technical writing.
It is the race condition, not the timeout, that causes the data corruption. Concessive Adverbials in Technical English
Use although, even though, despite, in spite of, while, whereas to acknowledge trade-offs and constraints in architecture decisions.
Although the caching layer reduces latency, it introduces consistency challenges. Quantification and Precision Language
Express exact quantities, proportions, and measurements precisely in technical reports: exactly, precisely, approximately, up to, at least, no more than.
Response time must not exceed 200 ms at the 99th percentile under a load of at least 1,000 requests per second. Epistemic Modality in Technical English
Express degrees of certainty and possibility using must, should, might, could, will, would in technical predictions, recommendations, and specifications.
This might be a memory leak, but we'd need a heap dump to confirm. Ellipsis in Technical Documentation
Avoid repetition by omitting repeated elements in lists, parallel structures, and comparisons in technical docs and commit messages.
The API supports GET, POST, PUT, and DELETE — the last two require authentication. Phrasal Verbs for IT Professionals
Master essential IT phrasal verbs: set up, pull in, roll back, spin up, tear down, hand off, kick off, wrap up, sign off, fall back.
We need to spin up a staging environment before we roll out the feature. Nominal Relative Clauses in Tech Discussions
Use "what we need is...", "what happens is...", "what matters is..." structures to frame technical problems and solutions.
What we need is a circuit breaker between the API gateway and the downstream services. Approximation and Hedging Numbers
Use approximately, roughly, around, about, nearly, up to, at least, in the order of to express technical estimates with appropriate precision.
The latency is roughly 50 ms under normal load, but spikes to around 500 ms under peak traffic. Evaluative Adjectives in Technical Writing
Use robust, scalable, reliable, maintainable, idiomatic, ergonomic, opinionated correctly in technical architecture reviews and documentation.
The current approach is not scalable — we need a more robust solution. Negative Inversion for Emphasis
Use inverted negatives for emphasis in formal tech writing: Never have we encountered, Not only did the service..., Under no circumstances should....
Under no circumstances should the private key be committed to version control. Causative Structures in Incident Reports
Express cause-and-effect precisely in postmortems: caused by, resulted in, led to, triggered, was exacerbated by, contributed to.
The deployment failure was caused by a misconfigured environment variable, which triggered a cascade of downstream errors. Metalanguage in Technical Documentation
Use signposting language to guide readers: this section explains, as mentioned above, for more details see, to summarise, it is worth noting.
As mentioned in the previous section, the API uses JWT for authentication. For more details, see the Security Architecture guide. Spatial Prepositions in System Descriptions
Use within, across, between, outside, inside, into, from, through correctly to describe system architecture, data flow, and component relationships.
Data flows from the ingestion layer through the transformation pipeline into the warehouse. Advanced Conditionals for IT Problem-Solving
Mixed conditionals, counterfactual analysis, and conditional chains as used in bug investigations, postmortems, and architecture trade-off discussions.
Had we implemented circuit breakers earlier, the cascade failure would not have propagated. Modal Verbs: Obligation & Permission
Must, have to, need to, should, may, can — used in API documentation, security policies, and technical specifications to express requirements and permissions.
API clients must include a valid Bearer token; they may optionally pass an Idempotency-Key header. Past Tenses in Incident Reports
Simple past, past perfect, and past continuous for accurate incident timelines, root cause analyses, and postmortem narratives.
At 03:14 UTC, the service had already been degraded for 20 minutes when the on-call engineer was paged. Future Language in Technical Roadmaps
Will, going to, present continuous, future perfect — choosing the right future form for roadmap discussions, sprint planning, and release announcements.
We are deprecating v1 of the API in Q3; v2 will be the only supported version from Q4 onwards. Complex Prepositions in Technical English
Multi-word prepositions (with respect to, in terms of, as a result of, in accordance with, prior to) used in formal technical documentation and architecture proposals.
With respect to performance, the new implementation reduces latency by 40% in terms of P99 response time. Verb Collocations with Technical Nouns
Which verbs naturally pair with technical nouns: run/invoke/trigger tests; deploy/ship/push code; raise/throw/catch exceptions; spin up/provision/allocate resources.
The pipeline raises an exception when it catches a connection timeout, then invokes the retry handler. Abstract Nouns in Architecture Discussions
Use scalability, resilience, observability, maintainability, testability, and discoverability as architectural quality attributes — how to discuss and trade off these abstract nouns.
We traded some observability for reduced operational complexity — the team felt maintainability was the higher priority. Signposting in Technical Presentations
Guide your audience through technical content using discourse markers: firstly, furthermore, in contrast, to summarise, as a result, building on this, to illustrate.
To summarise the trade-offs: firstly, microservices improve scalability; however, they introduce operational complexity. Expressing Numbers and Metrics Precisely
Express technical metrics precisely: percentages, multiples (3x), latency (P99), throughput (req/s), and proportions — the right grammar for engineering reports.
We achieved a 3× reduction in build time, bringing P50 from 12 minutes to under 4 minutes. Formal vs Informal Register in IT
Adapt your English to context: technical specs vs Slack messages vs architecture docs vs code comments — choosing the right register for each communication channel.
Slack: "heads up — build is broken" vs ADR: "The deployment pipeline failed due to a misconfigured environment variable." Subjunctive Mood in Technical Documentation
Use the mandative subjunctive ("It is required that the client send...") correctly in API docs, RFCs, and security policies.
It is essential that the token be refreshed before it expires. Ellipsis in Technical Communication
Omit repeated elements for conciseness in commit messages, PR titles, changelogs, and technical lists without losing clarity.
The service supports GET and POST — the latter requires authentication. Cohesive Devices in Technical Writing
Use pronouns, demonstratives (this, these, such), and reference chains to create coherent flow in documentation and design docs.
The service exposes three endpoints. These are documented in the OpenAPI spec. Nominalisation in IT English
Convert verbs into noun phrases (deploy → deployment, implement → implementation) for formal sprint reports, postmortems, and architecture proposals.
The implementation of the caching layer resulted in a 40% reduction in database load. Imperative Language in IT Documentation
Write clear CLI instructions, README steps, and setup guides using bare imperatives, negative imperatives, and parallel command sequences.
Run the migration script. Set the DATABASE_URL environment variable. Do not commit the .env file. Verb Aspect in Technical Communication
Choose between simple, progressive, and perfect aspect for standup updates, release notes, and deployment status messages.
We deployed the fix (simple past) vs We have deployed the fix (present perfect, still relevant now). Articles in Technical English
Master a/an/the/zero article with technical nouns: "a server", "the database", "memory management" (zero article) — avoid the most common non-native errors.
The API returns an error if the request body is missing a required field. Prepositions of Time in IT English
Use at, on, in, by, during, for, within correctly in standup updates, sprint planning, and release schedules.
We aim to ship this by Friday. The deployment runs at midnight on Tuesdays. Discourse Connectors in Technical Docs
Use however, therefore, consequently, given that, provided that, unless to build logical arguments in API docs and architecture decision records.
The service is stateless; therefore, horizontal scaling requires no session synchronisation. Active vs Passive Voice Choice
Choose between active and passive voice appropriately for commit messages, RCA documents, user stories, and API documentation.
Active: "The engineer deployed the fix." Passive: "The fix was deployed at 03:00 UTC." — context determines which is clearer. Punctuation in Technical Writing
Colons, semicolons, em-dashes, Oxford comma, and compound-adjective hyphens — the rules for professional technical documentation and PR descriptions.
The system supports three modes: read-only, write-only, and read–write. Zero Article in Technical English
When NOT to use a/an/the with uncountable nouns, generic plurals, technology names, and documentation headings.
Software must handle errors. Developers use Python. Access is denied. Reduced Relative Clauses in Tech Docs
Reduce "which is" / "that is" / "who manages" relative clauses into participial phrases for more concise technical writing.
"The function which is called sync()" → "the sync() function" or "the called sync() function". Sentence Fragments in IT Documentation
Understand when sentence fragments are acceptable in bullet lists, error messages, and UI labels — and when complete sentences are required.
Bullet: "Handles retries automatically." ✓ vs prose: "File not found." (acceptable in error messages). Listing Structures and Parallel Structure
Write grammatically parallel lists, step-by-step instructions, and comparisons in technical writing — avoid mixed verb forms and structures.
"Run the command, open the file, update the config" — not "Running the command, open the file, and you should update". Contractions and Register in IT English
Know when contractions (don't, isn't, we've) are appropriate — Slack vs API docs vs PR descriptions vs code comments.
Slack: "We've pushed the fix." API docs: "Do not commit sensitive credentials to version control." Existential "There" in Technical Writing
Decide when "there is/are" helps clarity and when to rewrite for directness in technical documentation.
"There is a bug in the cache layer" vs "A bug in the cache layer causes stale reads." Nominal Groups in IT English
Parse and construct complex noun phrases (nominal groups) such as "distributed event-driven data processing pipeline" — essential for reading and writing IT documentation.
"real-time event-driven data processing platform" — 5 pre-modifiers plus head noun. Tag Questions in Technical Conversations
Form and use tag questions correctly in standups, code reviews, and technical discussions — confirm assumptions politely.
"The cache is enabled, isn't it?" / "This should work, shouldn't it?" Sentence Types in IT Communication
Use declarative, imperative, interrogative, and exclamative sentences strategically in API docs, code review comments, and runbooks.
Imperative: "Run the migration." Declarative: "The function returns a string." Interrogative: "How does caching work?" Verb Phrase Patterns in Technical English
Master IT-specific verb phrases: spin up, roll back, scale out, tear down, cut over, hand off, kick off, sign off — with correct grammar and register.
We need to spin up a staging cluster and hand off the deployment to the SRE team. Nominal (Noun) Clauses in Technical Communication
Use that-clauses and wh-clauses correctly in postmortems, design docs, and meeting notes: "the team agreed that...", "what the logs show is...", "whether we should...".
What the monitoring revealed is that the cache miss rate exceeded 80% during the outage. Stance Adverbials in Technical Writing
Choose the right stance adverbial — frankly, notably, crucially, ideally, arguably, admittedly, technically speaking — to signal your perspective in RFCs and postmortems.
Arguably, the monolith approach is simpler; crucially, however, it will not scale beyond 10x our current load. Specification Language: MUST, SHOULD, MAY
Apply RFC 2119 keywords correctly in technical specifications: MUST, MUST NOT, SHOULD, SHOULD NOT, MAY, REQUIRED, OPTIONAL.
All API clients MUST include a valid Bearer token. The Idempotency-Key header SHOULD be included for POST requests. Process Description Language in Technical Docs
Use passive constructions to describe technical processes: is processed, is triggered when, results in, is validated against, is persisted to, is propagated to.
The request is validated against the JSON schema, then is persisted to the database and propagated to the event bus. Contrastive Structures in Technical English
Express technical trade-offs using "it is X, not Y", "rather than", "as opposed to", and "unlike X, Y" in architecture discussions and PR reviews.
It is the query plan, not the index itself, that is causing the performance degradation. Article Choice with Technical Terms
Decide between a/an/the/zero article with technical nouns, abbreviations, and product names — including "an API", "the database", and zero article for generic tech.
An API gateway sits in front of the microservices. Traffic flows through a load balancer. Coordination Patterns in Technical English
Use both…and, not only…but also, either…or, neither…nor, and as well as correctly in technical documentation and engineering proposals.
Not only does the solution reduce latency, but it also lowers infrastructure costs. Evaluative Language in Technical Communication
Choose accurate evaluative words for code review and architecture discussions: appropriate, suboptimal, viable, robust, brittle, idiomatic, over-engineered, pragmatic.
This approach is technically viable but arguably over-engineered for the current scale. Temporal Language in IT: Timing and Sequences
Use temporal connectors correctly in runbooks and deployment plans: once, as soon as, by the time, upon completion, prior to, following, concurrent with, in parallel with.
Once the migration completes, prior to re-enabling traffic, run the validation script. Hedging Language in Risk Communication
Express degrees of uncertainty in incident reports, risk assessments, and security briefings.
"There is a risk of service degradation if the cache is not invalidated." Counterfactual Language in Technical English
Use 3rd conditional and mixed conditionals in postmortems and root cause analysis.
"If we had added monitoring, we would have caught this earlier." Cause and Effect Language in Technical Writing
Use precise cause-effect connectors in incident reports and debugging documentation.
"The memory leak stemmed from an unclosed database connection pool." Scope and Qualification Language in Technical English
Define scope and add qualifications in API docs, SLAs, and architecture documents.
"This endpoint is limited to authenticated users, subject to rate limiting." Discourse Patterns in Technical Presentations
Use signposting language to structure architecture talks, sprint demos, and tech talks.
"Moving on to the performance implications of this approach..." Referencing Language in Technical Documents
Refer to earlier content effectively in technical specs, RFCs, and design documents.
"As noted in the requirements, this feature must support concurrent access." Action-Oriented Language in Technical Meetings
Assign and track actions clearly in sprint planning, design reviews, and 1-on-1s.
"Can you own the database migration task before the next sprint?" Contrast and Concession in Technical Argumentation
Use advanced concession language in architecture trade-off discussions and code reviews.
"While this approach has merits, the added complexity may outweigh the benefits." Quantification Language in Technical Reporting
Express precise quantities in performance reports, incident metrics, and sprint reviews.
"We observed a threefold increase in p99 latency during peak traffic." Register Shifting: Formal to Informal in IT English
Recognise and use appropriate register across documentation, Slack, and standups.
"The deployment pipeline encountered an issue." vs "Deploy broke — looking into it." Exemplification Language in Technical Writing
Choose the correct connector — such as, namely, in particular, e.g., including — to introduce examples in design docs and postmortems.
The endpoint accepts common formats, e.g., JSON, XML, and YAML. Verb-Noun Collocations in DevOps English
Use fixed verb-noun pairings correctly in incident reports and release notes: trigger a rollback, raise an incident, pay down technical debt.
The on-call engineer raised an incident at 03:14 UTC. Parenthetical Asides in Technical Writing
Punctuate clarifying asides and cross-references correctly with dashes, parentheses, and commas in design docs.
The cache layer (which had not been updated since the previous incident) was the primary contributor. Negation Scope and Ambiguity in Technical English
Place negation correctly relative to quantifiers and frequency adverbs to avoid ambiguity in specs and status reports.
Not all requests failed during the outage. Adjective Order in Technical Noun Phrases
Order multiple adjectives correctly before technical nouns in architecture diagrams and API docs.
A new robust distributed caching layer improved p99 latency. Verb Prefix Precision in Technical English
Choose the correct prefix — re-, de-, un- — so the verb expresses exactly the intended technical action in runbooks and tickets.
Once traffic has been migrated, decommission the legacy load balancer. Emphatic Do in Technical English
Use do/does/did for emphasis to affirm facts and correct false assumptions in code reviews and postmortems.
The function does handle errors — see the try/catch block on line 42. Dependent Prepositions After Verbs in Technical English
Memorize the correct fixed preposition after common technical-writing verbs: rely on, result in, comply with, account for.
Retry storms account for nearly 40% of total request volume. Attribution and Citation Language in Technical Writing
Attribute claims and recommendations correctly to external sources and internal documentation.
According to the AWS Well-Architected Framework, retries should use exponential backoff with jitter. Superlative Constructions in Technical English
Form regular, irregular, and emphatic superlatives correctly in performance reports and vendor comparisons.
This is one of the most common causes of memory leaks in long-running Node.js processes. Correlative Conjunctions in Technical Writing
Practice correlative conjunction pairs — both...and, either...or, neither...nor, not only...but also — in RFCs, postmortems, and code reviews.
The migration script must both validate the schema and roll back automatically on failure. Resultative Clauses in Technical Writing
Practice resultative clause structures — so...that, such...that, so that — in postmortems, design docs, and code comments.
The queue grew so large that the consumer service ran out of memory. Absolute Constructions in Technical Writing
Practice absolute constructions — noun + participle, with + noun + participle, having + past participle — in postmortems, design docs, and code reviews.
The migration being complete, the team decommissioned the legacy database. Non-Finite Purpose Clauses in Technical Writing
Practice non-finite purpose clauses — to + verb, in order to, so as not to, for + gerund — versus finite so that clauses in specs and RFCs.
We added a retry layer to handle transient failures. Extraposition with Anticipatory It in Technical Specs
Practice extraposition — moving heavy clausal subjects to the end using anticipatory it — in specs, RFCs, and design docs.
It is important to understand that the cache invalidates asynchronously. Stance Nouns with That-Clauses in Technical Writing
Practice stance nouns like concern, assumption, possibility, and chance with appositive that-clauses in design docs, RFCs, and code reviews.
There is a concern that the new schema might break backward compatibility. Modal Adverb Hedges in Technical Writing
Practice modal adverbs of likelihood — probably, likely, almost certainly, presumably — for precise, calibrated hedging in postmortems and code reviews.
The service will probably fail under sustained load above 5k rps. Mitigated Directives in Technical Writing
Practice mitigated directives — could you, it might be worth, have you considered, needs to be fixed — for code reviews and design feedback.
Could you extract this into a helper function? Cataphoric Reference in Technical Writing
Practice cataphoric reference — this, the following, here's what — that point forward to upcoming content in specs, postmortems, and design docs.
This is the key insight: caching alone will not fix the latency problem. Existential There Constructions in Technical Writing
Practice existential there is/are constructions — subject-verb agreement, relative clauses, and when to avoid them for conciseness — in specs and postmortems.
There are three known issues with the current implementation. Participial Time Clauses in Technical Writing
Practice participial time clauses — before/after/while + gerund, having + past participle — and avoiding dangling participles in technical docs.
Before deploying to production, run the full regression suite. Frequently Asked Questions
Why do IT professionals need grammar exercises?
Grammar mistakes in technical writing reduce clarity and can cause misunderstandings. Using the wrong tense in a postmortem, an incorrect modal verb in a risk assessment, or passive voice overuse in API documentation are all common issues that grammar exercises specifically target.
What grammar topics are covered in these exercises?
Topics include conditionals (if this deploy fails…), passive voice for documentation, modal verbs for recommendations (should, could, must), tenses in status updates, hedging language, transition words, relative clauses, noun phrases, and advanced structures like cleft sentences and discourse markers.
Do the grammar exercises use real IT examples?
Yes. Every exercise uses sentences drawn from real IT contexts — code review comments, sprint retrospective notes, incident reports, architecture documents, and API documentation. You will never practice grammar with holiday or restaurant examples.
What is hedging language and why does it matter in IT?
Hedging language expresses degrees of certainty: "This might be related to…", "It's possible that…", "We could consider…". In IT, it's essential for estimates, risk communication, and technical proposals where overpromising is a professional hazard.
What is the difference between active and passive voice in technical writing?
Active voice names the actor ("The team deployed the service"). Passive voice omits it ("The service was deployed"). Passive is appropriate in formal docs, API reference (The request is authenticated), and postmortems. Active voice is clearer for instructions and direct communication.
Which grammar topic is most useful for code reviews?
Modal verbs are the most immediately useful. Choosing between "you should refactor this", "you could extract this", and "this must be fixed before merge" communicates very different levels of urgency. The Modal Verbs for Recommendations set directly targets this skill.
Are there grammar exercises for writing RFCs or Architecture Decision Records?
Yes. The Advanced Conditionals, Inversion for Formal Communication, and Advanced Discourse Markers sets are specifically useful for RFC and ADR writing. The Concise IT Writing set helps remove filler phrases that weaken proposals.
I already know English grammar rules. Will these exercises still help me?
Yes. Knowing a rule and applying it instinctively in a fast-paced standup or under deadline pressure are different skills. These exercises build automaticity — the ability to use correct grammar without conscious effort — through IT-specific practice.
What is the hardest grammar topic for non-native IT professionals?
Based on common patterns, the most challenging areas are: (1) choosing the right modal verb for code reviews, (2) using tense correctly in postmortems (past perfect vs simple past), and (3) writing concise technical sentences without redundant filler phrases.
How long does each grammar exercise set take?
Most grammar sets contain 5–20 questions and take 5–15 minutes. Sets are self-contained and can be completed in a single session. The Advanced topics like cleft sentences and inversion are shorter (5 questions) for focused practice.