Articles and countable nouns in tech writing

Hindi, Marathi, Urdu, Russian, Korean and Polish have no words for a and the: the World Atlas of Language Structures (WALS) codes 198 of the 620 languages in its sample that way. If you think in one of them, English articles are a habit to build rather than a word to translate, and a bug report such as “Fixed bug in payment page” is what happens without it.

This lesson gives you four questions to ask of every noun, so you can choose a, an, the or no article in tickets, docs and stand-ups. You will choose a or an by sound, use nouns such as feedback and software that take no a, and write plurals such as APIs without an apostrophe. Small programs check each habit, and you can run them on your own sentences.

A or an for something new, the for something the reader knows

Compare two lines a teammate might post in the team channel: “A test failed on staging” and “The test failed on staging”. The first reports one test among many, one the reader has not heard of yet. The second says that the test you were both waiting for has failed. One word changes what the reader does next: look up which test, or go straight to the one they know.

English marks this difference with its articles. A or an introduces something the reader does not know yet, or any one of a kind: a user, a bug, a new branch. The points at something the reader can identify, because you have mentioned it already or because there is only one in your shared context: the build, the main branch, the login page of your app. A singular countable nouncountable noun: A noun with a singular and a plural that you can count: one bug, two bugs. In the singular it needs a, an, the or another determiner. such as bug never stands alone. It needs an article or another determinerdeterminer: A word in front of a noun that says which one or how many, such as a, an, the, this, my, each or some. A singular countable noun always needs one. that does the same job, such as this, my or each. The British Council’s elementary lesson on articles gives the same rules, with drills if you want more practice.

Step through the four questions with five nouns from this lesson’s messages:

The program below checks the first rule for you. It looks for a singular countable noun from its list with no article or other determiner in front of it, in a bug report and a stand-up update, before and after a rewrite:

// A check for one common slip: a singular countable noun with no article in front of it ("fixed bug in payment
// page"). It knows only the nouns and the describing words in its two lists, so treat a flag as a question for the
// writer, and add your own team's words to the lists.

const NOUNS = new Set([
  'app', 'bug', 'build', 'button', 'check', 'crash', 'error', 'file', 'fix', 'flow', 'issue', 'log', 'page', 'pr',
  'release', 'screen', 'server', 'service', 'test', 'token', 'user',
]);
// Words that can stand between an article and its noun ("the new login page").
const DESCRIBING = new Set(['android', 'auth', 'build', 'correct', 'login', 'new', 'old', 'payment', 'refund', 'staging', 'token', 'wrong']);
// Words that already do the article's job.
const DETERMINERS = new Set([
  'a', 'an', 'the', 'this', 'that', 'my', 'your', 'our', 'their', 'its', 'his', 'her', 'each', 'every', 'any', 'no',
  'one', 'another', 'which', 'what', 'some',
]);

const isNoun = (w) => NOUNS.has((w ?? '').toLowerCase());

function bareNouns(sentence) {
  const words = sentence.replace(/[.,:;!?]/g, ' ').split(/\s+/).filter(Boolean);
  const flagged = [];
  words.forEach((w, i) => {
    if (!isNoun(w)) return;
    // A noun followed by a number is a name: "release 4.2", "PR 412".
    if (/^\d/.test(words[i + 1] ?? '')) return;
    // A noun in front of another noun describes it: "build log", "token check".
    if (isNoun(words[i + 1])) return;
    let start = i;
    while (start > 0 && DESCRIBING.has(words[start - 1].toLowerCase())) start--;
    const before = (words[start - 1] ?? '').toLowerCase();
    if (!DETERMINERS.has(before) && !/'s$/.test(before)) flagged.push(words.slice(start, i + 1).join(' '));
  });
  return flagged;
}

function report(label, text) {
  let total = 0;
  console.log(label);
  for (const s of text.split(/(?<=[.!?])\s+/)) {
    const flags = bareNouns(s);
    total += flags.length;
    console.log(`  ${s}`);
    if (flags.length) console.log(`    no article: ${flags.join(', ')}`);
  }
  console.log(`  ${total} noun phrase${total === 1 ? '' : 's'} without an article\n`);
}

const bugBefore =
  'Sign-in fails in Android app. User enters correct OTP but screen shows error. ' +
  'Issue started after release 4.2. Fix is to update token check in auth service.';
const bugAfter =
  'Sign-in fails in the Android app. A user enters the correct OTP, but the screen shows an error. ' +
  'The issue started after release 4.2. The fix is to update the token check in the auth service.';

const standupBefore =
  'Yesterday I fixed bug in payment page and raised PR. Today I will write test for refund flow. ' +
  'Blocker: staging server is down, so I need access to build log.';
const standupAfter =
  'Yesterday I fixed a bug on the payment page and raised a PR. Today I will write a test for the refund flow. ' +
  'Blocker: the staging server is down, so I need access to the build log.';

report('Bug report, before', bugBefore);
report('Bug report, after', bugAfter);
report('Stand-up update, before', standupBefore);
report('Stand-up update, after', standupAfter);

Bug report, before
  Sign-in fails in Android app.
    no article: Android app
  User enters correct OTP but screen shows error.
    no article: User, screen, error
  Issue started after release 4.2.
    no article: Issue
  Fix is to update token check in auth service.
    no article: Fix, token check, auth service
  8 noun phrases without an article

Bug report, after
  Sign-in fails in the Android app.
  A user enters the correct OTP, but the screen shows an error.
  The issue started after release 4.2.
  The fix is to update the token check in the auth service.
  0 noun phrases without an article

Stand-up update, before
  Yesterday I fixed bug in payment page and raised PR.
    no article: bug, payment page, PR
  Today I will write test for refund flow.
    no article: test, refund flow
  Blocker: staging server is down, so I need access to build log.
    no article: staging server, build log
  7 noun phrases without an article

Stand-up update, after
  Yesterday I fixed a bug on the payment page and raised a PR.
  Today I will write a test for the refund flow.
  Blocker: the staging server is down, so I need access to the build log.
  0 noun phrases without an article

The two drafts left 15 noun phrases without an article, and the rewrites none. The rewrite added a for the bug, the user and the PR, which the reader meets for the first time, and the for the app, the screen, the payment page and the staging server, of which there is only one. The checker also missed a slip: correct OTP needs the, but OTP is not in its list. A checker finds the slips it knows; reading the sentence finds the rest.

Every flag, whatever the noun, comes down to the same two questions: can you count it, and does the reader know which one you mean?

No article for things in general, and none before product names

Not every noun needs an article. A plural or an uncountable noun used in general takes none: “Logs help when a build fails”, “Code needs tests”, “Feedback makes a design better”. These sentences are about logs, code and feedback of every kind, not about some logs the reader knows. The British Council’s lesson gives the rule for general statements: “we normally use a plural or uncountable noun with no article”. Add the and the meaning narrows: “The logs show a timeout” means the logs of this incident.

Product names take no article either. Google’s style guide says not to put the before a product name unless the name modifies something else, and to use the before tool and API names. So you install Kubernetes, open the Kubernetes dashboard and call the Transcoder API. Five sentences from team messages show both rules at work:

Keep the articles in headings and short labels too. Google’s guide asks writers not to skip articles for brevity, “including in headings and titles”, and gives Create a VM instance rather than Create VM instance. Microsoft’s writing tips give the reason that matters for a global team: an article tells the reader, and translation software too, that a noun is coming and which words describe it.

A or an goes by sound, so it is an API and a URL

Is it a API or an API? The letter does not decide; the first sound does. An goes before a vowel sound and a before a consonant sound, whatever the spelling: an hour (the h is silent), a user (said “you-zer”), a one-time password (“wun”). Google’s guide gives the same rule, and the case that matters most in tech follows from it: an abbreviation said letter by letter starts with the sound of its first letter’s name. API is said “ay-pee-eye”, so it is an API. URL is “you-ar-el”, the pronunciation Oxford’s learner’s dictionary gives, so it is a URL.

Some abbreviations are said two ways, and then the rule has two answers. Oxford lists both “eff-ay-cue” and “fack” for FAQ. Google’s word list prefers a SQL, “pronounced ‘a sequel’”, and an SAP system, because SAP is said letter by letter; its general advice is to base the choice on the pronunciation that is most common for your audience. The program applies the rule to 18 words and abbreviations from tickets and docs, then checks seven short phrases:

// A or an goes by the first SOUND of the next word, not by its first letter. An abbreviation said letter by letter
// starts with the sound of its first letter's name (A is "ay", F is "eff", U is "you"); one said as a word starts
// like that word. Where readers say a term two ways, the rule gives two answers, and you choose the one most of your
// readers use.

// The names of the letters, as they are said.
const LETTER = {
  A: 'ay', B: 'bee', C: 'see', D: 'dee', E: 'ee', F: 'eff', G: 'jee', H: 'aitch', I: 'eye', J: 'jay', K: 'kay',
  L: 'el', M: 'em', N: 'en', O: 'oh', P: 'pee', Q: 'cue', R: 'ar', S: 'ess', T: 'tee', U: 'you', V: 'vee',
  W: 'double-you', X: 'ex', Y: 'why', Z: 'zed',
};
const DIGIT = { 0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine' };

// How a term is said when the spelling misleads: a silent h, a u or an o said with a consonant sound, and the
// abbreviations that many people say as a word. Add your own terms here.
const SAID = {
  hour: ['our'],
  honest: ['onnest'],
  user: ['yoo-zer'],
  unique: ['yoo-neek'],
  'one-time': ['wun-time'],
  SQL: ['see-kwel', 'ess-cue-el'],
  FAQ: ['fack', 'eff-ay-cue'],
};

// Letter by letter: "S3" is "ess three", "HTTP" is "aitch tee tee pee".
const spelledOut = (term) => [...term].map((c) => LETTER[c] ?? DIGIT[c] ?? c).join(' ');
const saidAs = (term) => SAID[term] ?? (/^[A-Z0-9]+$/.test(term) ? [spelledOut(term)] : [term.toLowerCase()]);
// A vowel sound starts with a, e, i, o or u in these spellings ("you" and "wun" start with consonant sounds).
const articleFor = (spoken) => (/^[aeiou]/.test(spoken) ? 'an' : 'a');

const TERMS = ['hour', 'honest', 'user', 'unique', 'one-time', 'URL', 'API', 'HTTP', 'HR', 'LLM', 'MVP', 'NPM', 'S3', 'SAP', 'XML', 'EOD', 'SQL', 'FAQ'];

console.log('term       said as                 article');
const counts = { a: 0, an: 0, either: 0 };
for (const term of TERMS) {
  const ways = saidAs(term);
  const articles = [...new Set(ways.map(articleFor))];
  const verdict = articles.length > 1 ? 'either: choose by how your readers say it' : articles[0];
  counts[articles.length > 1 ? 'either' : articles[0]]++;
  console.log(`${term.padEnd(10)} ${ways.join(' / ').padEnd(23)} ${verdict}`);
}
console.log(`\n${counts.an} take an, ${counts.a} take a, ${counts.either} depend on the reader\n`);

// The same rule as a check on short phrases.
const PHRASES = ['a hour', 'an user', 'a API', 'a URL', 'an HTTP request', 'an SQL query', 'a SQL query'];
for (const phrase of PHRASES) {
  const [written, term] = phrase.split(' ');
  const allowed = [...new Set(saidAs(term).map(articleFor))];
  const verdict = allowed.includes(written) ? 'fine' : `write "${allowed.join('" or "')} ${term}"`;
  console.log(`${phrase.padEnd(16)} ${verdict}`);
}

term       said as                 article
hour       our                     an
honest     onnest                  an
user       yoo-zer                 a
unique     yoo-neek                a
one-time   wun-time                a
URL        you ar el               a
API        ay pee eye              an
HTTP       aitch tee tee pee       an
HR         aitch ar                an
LLM        el el em                an
MVP        em vee pee              an
NPM        en pee em               an
S3         ess three               an
SAP        ess ay pee              an
XML        ex em el                an
EOD        ee oh dee               an
SQL        see-kwel / ess-cue-el   either: choose by how your readers say it
FAQ        fack / eff-ay-cue       either: choose by how your readers say it

12 take an, 4 take a, 2 depend on the reader

a hour           write "an hour"
an user          write "a user"
a API            write "an API"
a URL            fine
an HTTP request  fine
an SQL query     fine
a SQL query      fine

Twelve of the 18 take an, four take a, and two, SQL and FAQ, depend on how your readers say them. The letters to watch are the ones whose names start with a vowel sound: A, E, F, H, I, L, M, N, O, R, S and X. That is why an HR policy, an LLM, an MVP and an S3 bucket are right, although each starts with a consonant letter.

Feedback, software and advice take no a and no plural

Oxford’s learner’s dictionary marks feedback, software, information, advice, hardware and equipment as uncountable, and lists several of them among the uncountable nouns often used wrongly. An uncountable noununcountable noun: A noun with no plural that takes no a or an, such as feedback, software or advice. Use some, a piece of or a countable noun instead. has no plural and takes no a or an. Write some feedback, a piece of advice or two new tools, never a feedback, advices or softwares. Oxford’s note on advice says it directly: “We say a piece of advice (not ‘an advice’)”.

Two tech nouns need a second look. Code meaning program instructions is uncountable, as in Oxford’s example “a few lines of code”, so you push the code, never the codes. Separate codes, such as error codes or OTP codes, are countable. Data is marked both uncountable and plural: “The data shows a spike” is normal at work, and “These data show” is the form of specialist writing, such as scientific papers.

The program checks ten sentences for the noun forms of this section and the next:

// Checks ten sentences for the noun forms this lesson names: a or an, or a plural, on an uncountable noun ("a
// feedback", "softwares"); "codes" for program code; an apostrophe in the plural of an abbreviation ("API's"); a
// plural unit after a number ("64 GBs"); and the plural of a product name ("two GitHubs").

// Marked [uncountable] in the Oxford Advanced Learner's Dictionary, with words to use instead of a or an.
const UNCOUNTABLE = {
  feedback: 'some feedback, or a comment',
  advice: 'some advice, or a piece of advice',
  information: 'some information, or a detail',
  software: 'some software, or a program or a tool',
  hardware: 'some hardware, or a device',
  equipment: 'some equipment, or a piece of equipment',
};
// "codes" is right for separate codes, such as error codes, and wrong for program code.
const CODE_KINDS = /\b(?:error|status|exit|response|country|discount|OTP|QR)\s+codes\b/i;
const PRODUCTS = ['GitHub'];

function problems(sentence) {
  const out = [];
  for (const [noun, use] of Object.entries(UNCOUNTABLE)) {
    // "a software engineer" is fine: there the noun describes the next noun.
    const alone = `(?=[.,;:!?]|$|\\s(?:on|about|for|from|of|to|in|with|and|is|was)\\b)`;
    if (new RegExp(`\\ban? (?:\\w+ )?${noun}${alone}`, 'i').test(sentence)) out.push(`no a or an before ${noun}: ${use}`);
    if (new RegExp(`\\b${noun}s\\b`, 'i').test(sentence)) out.push(`${noun} has no plural: ${use}`);
  }
  if (/\bcodes\b/i.test(sentence) && !CODE_KINDS.test(sentence)) out.push('program code is uncountable: the code');
  const apostrophe = sentence.match(/\b[A-Z][A-Z0-9]*[A-Z0-9]'s\b/g);
  if (apostrophe) out.push(`a plural takes s alone: ${apostrophe.map((a) => a.replace("'s", 's')).join(', ')}`);
  const unit = sentence.match(/\b\d+(?:\.\d+)?\s?(?:KB|MB|GB|TB)s\b/g);
  if (unit) out.push(`a unit's abbreviation stays singular: ${unit.map((u) => u.slice(0, -1)).join(', ')}`);
  for (const p of PRODUCTS) {
    if (new RegExp(`\\b${p}s\\b`).test(sentence)) out.push(`no plural of a product name: two ${p} repositories, projects or files`);
  }
  return out;
}

const PAIRS = [
  ['Thanks for the feedbacks on my PR.', 'Thanks for the feedback on my PR.'],
  ['Can you give me an advice on the schema?', 'Can you give me some advice on the schema?'],
  ['We need more informations about the crash.', 'We need more information about the crash.'],
  ['The team installed two new softwares.', 'The team installed two new tools.'],
  ['I wrote the codes for the parser.', 'I wrote the code for the parser.'],
  ['The service returns three error codes.', 'The service returns three error codes.'],
  ["We expose three API's to partners.", 'We expose three APIs to partners.'],
  ['Each VM has 64 GBs of memory.', 'Each VM has 64 GB of memory.'],
  ['Clone both GitHubs before the workshop.', 'Clone both GitHub repositories before the workshop.'],
  ['The data shows a spike at 02:00 UTC.', 'The data shows a spike at 02:00 UTC.'],
];

let before = 0;
let after = 0;
PAIRS.forEach(([original, fixed], i) => {
  const found = problems(original);
  before += found.length;
  after += problems(fixed).length;
  console.log(`${String(i + 1).padStart(2)}  ${original}`);
  for (const f of found) console.log(`      ${f}`);
  if (fixed !== original) console.log(`    -> ${fixed}`);
  else console.log('    (nothing to fix)');
});
console.log(`\nProblems: ${before} before, ${after} after`);

 1  Thanks for the feedbacks on my PR.
      feedback has no plural: some feedback, or a comment
    -> Thanks for the feedback on my PR.
 2  Can you give me an advice on the schema?
      no a or an before advice: some advice, or a piece of advice
    -> Can you give me some advice on the schema?
 3  We need more informations about the crash.
      information has no plural: some information, or a detail
    -> We need more information about the crash.
 4  The team installed two new softwares.
      software has no plural: some software, or a program or a tool
    -> The team installed two new tools.
 5  I wrote the codes for the parser.
      program code is uncountable: the code
    -> I wrote the code for the parser.
 6  The service returns three error codes.
    (nothing to fix)
 7  We expose three API's to partners.
      a plural takes s alone: APIs
    -> We expose three APIs to partners.
 8  Each VM has 64 GBs of memory.
      a unit's abbreviation stays singular: 64 GB
    -> Each VM has 64 GB of memory.
 9  Clone both GitHubs before the workshop.
      no plural of a product name: two GitHub repositories, projects or files
    -> Clone both GitHub repositories before the workshop.
10  The data shows a spike at 02:00 UTC.
    (nothing to fix)

Problems: 8 before, 0 after

Eight of the ten had a problem, and none of the rewrites has one. Sentences 6 and 10 were right all along: three error codes are separate codes, and “the data shows” is fine at work. When a countable word says what you mean, use it:

Plurals of abbreviations take s, never an apostrophe

Google’s guide treats abbreviations as regular words in the plural: “APIs, SKEs, and IDEs”, not “API’s, SKE’s, and IDE’s”. Abbreviations that end in s, sh, ch or x take es, as in OSes. An apostrophe before the s makes a plural look like a possessive, as in “the API’s rate limit”, and the guide warns that this can confuse readers and cause problems in translation. Sentences 7, 8 and 9 of the last program are this section’s three slips.

The rules for units and product names come from the same guide. A unit’s abbreviation after a number stays singular, 64 GB, while a unit you spell out takes the plural, 64 gigabytes. A product, feature or company name takes no plural or possessive form: say what you have two of, as in two GitHub repositories.

Practise: a bug report, a README and an update

The exercise holds three short texts with the slips of this lesson: missing articles, a or an chosen by the letter, uncountable nouns with a or a plural, and plurals with an apostrophe. Fix them inside the quotes; the sample tests check each habit and that every fact survives:

// Fix the articles and noun forms of each text: edit the words inside the quotes, and keep every fact.

// 1. A bug report.
export const report =
  'Export button crashes app on settings page. Steps: open app, go to settings page and tap Export button. ' +
  "App shows a error and closes. Expected: file with user's data downloads. " +
  "Crash started after release 3.4, and I reproduced it on two APK's.";

// 2. A section of a README.
export const readme =
  'The tool sends a alert to the team channel when API returns error. To install it, you need a API key and ' +
  'Node 24. Settings are in config file at root of repository. For more informations, see FAQ.';

// 3. A status update.
export const update =
  'Done: migrated orders table to new schema and got a feedback from QA. Next: write test for refund flow. ' +
  'Blocker: I need an advice on index for status column.';

import { test, assert } from 'mysmartcopilot:test';
import { report, readme, update } from './fixes.mjs';

// The lesson's checks, with the nouns of these three texts.
const NOUNS = new Set([
  'alert', 'api', 'app', 'button', 'column', 'crash', 'error', 'faq', 'file', 'flow', 'index', 'key', 'page',
  'repository', 'root', 'schema', 'table', 'test', 'tool',
]);
const DESCRIBING = new Set(['api', 'config', 'export', 'new', 'orders', 'refund', 'settings', 'status']);
const DETERMINERS = new Set([
  'a', 'an', 'the', 'this', 'that', 'my', 'your', 'our', 'their', 'its', 'each', 'every', 'any', 'no', 'one',
  'another', 'some',
]);
const isNoun = (w) => NOUNS.has((w ?? '').toLowerCase());

function bareNouns(text) {
  const flagged = [];
  for (const sentence of text.split(/(?<=[.!?])\s+/)) {
    const words = sentence.replace(/[.,:;!?]/g, ' ').split(/\s+/).filter(Boolean);
    words.forEach((w, i) => {
      if (!isNoun(w) || /^\d/.test(words[i + 1] ?? '') || isNoun(words[i + 1])) return;
      let start = i;
      while (start > 0 && DESCRIBING.has(words[start - 1].toLowerCase())) start--;
      const before = (words[start - 1] ?? '').toLowerCase();
      if (!DETERMINERS.has(before) && !/'s$/.test(before)) flagged.push(words.slice(start, i + 1).join(' '));
    });
  }
  return flagged;
}
const all = () => ({ report, readme, update });

test('every singular noun has an article or another determiner', () => {
  for (const [name, text] of Object.entries(all())) {
    assert.deepEqual(bareNouns(text), [], `${name}: these nouns have no article in front`);
  }
});

test('a or an matches the first sound', () => {
  for (const [name, text] of Object.entries(all())) {
    const anNeeded = text.match(/\ba (?:alert|error|API|index|hour|HTTP)\b/gi) ?? [];
    const aNeeded = text.match(/\ban (?:user|URL|unique|new|test|file|refund)\b/gi) ?? [];
    assert.deepEqual([...anNeeded, ...aNeeded], [], `${name}: a or an does not match the sound`);
  }
});

test('uncountable nouns take no a or an and no plural', () => {
  const alone = '(?=[.,;:!?]|$|\\s(?:on|about|for|from|of|to|in|with|and|is|was)\\b)';
  const withArticle = new RegExp(`\\ban? (?:\\w+ )?(?:feedback|advice|information|software)${alone}`, 'i');
  for (const [name, text] of Object.entries(all())) {
    assert.ok(!withArticle.test(text), `${name}: an uncountable noun has a or an`);
    assert.ok(!/\b(?:feedbacks|advices|informations|softwares)\b/i.test(text), `${name}: an uncountable noun has a plural`);
  }
});

test('plurals of abbreviations have no apostrophe', () => {
  for (const [name, text] of Object.entries(all())) {
    assert.ok(!/\b[A-Z][A-Z0-9]*[A-Z0-9]'s\b/.test(text), `${name}: a plural of an abbreviation has an apostrophe`);
  }
});

test('every fact stays', () => {
  const facts = {
    report: ['Export button', 'settings page', 'release 3.4', 'APK'],
    readme: ['alert', 'API key', 'Node 24', 'config file', 'FAQ'],
    update: ['orders table', 'QA', 'refund flow', 'status column', 'advice'],
  };
  for (const [name, list] of Object.entries(facts)) {
    for (const fact of list) assert.ok(all()[name].includes(fact), `${name} no longer says "${fact}"`);
  }
});

Then answer the questions on the five habits. The session opens with the habit your answers so far show to be the weakest, and moves on from there:

Interview questions

Warm-up (fresher to mid-level): Why do style guides ask you to keep articles, even in headings?

Because articles tell the reader which things are new and which they already know, and they mark where a noun phrase starts. “Restart the pod” and “Restart a pod” are different instructions. Google’s guide asks writers to include articles for ease of comprehension and translation, and not to drop them in headings: “Create a VM instance”, not “Create VM instance”. Microsoft’s tips add that translation software, like a human reader, uses the articles to find the nouns. Dropping them saves a few characters and moves the work to the reader.

The module’s question bank holds two longer questions on articles and nouns:

Key takeaways

• Give every singular countable noun an article: a or an for something the reader meets for the first time, the for something they can identify.
• Use no article for plurals and uncountable nouns in general statements or before product names, and keep articles in headings.
• Choose a or an by the first sound: an API, an HTTP request, a URL, a user; for SQL and FAQ, follow how your readers say them.
• Uncountable nouns such as feedback, software, information and advice take no a and no plural: use some, a piece of or a countable word.
• Write plurals of abbreviations with s alone, abbreviated units after numbers in the singular, and no plurals of product names.